home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / X11 / xsw / scales.c < prev    next >
C/C++ Source or Header  |  1995-07-04  |  84KB  |  2,605 lines
  1. /*
  2.  *    @(#) scales.c 12.1 95/07/05 SCOINC
  3.  */
  4. /***************************************************************************
  5.  *
  6.  *    Copyright (c) 1990-1993        The Santa Cruz Operation, Inc.
  7.  *
  8.  *    All rights reserved.  No part of this program or publication may be
  9.  *    reproduced, transmitted, transcribed, stored in a retrieval system,
  10.  *    or translated into any language or computer language, in any form or
  11.  *    by any means, electronic, mechanical, magnetic, optical, chemical,
  12.  *    biological, or otherwise, without the prior written permission of:
  13.  *
  14.  *        The Santa Cruz Operation , Inc.        (408) 425-7222
  15.  *        400 Encinal St., Santa Cruz, California 95060 USA
  16.  *
  17.  **************************************************************************/
  18. /*
  19.  * Modification History
  20.  *
  21.  * S002, 27-May-93, rickra
  22.  *     Added support for pixmaps 
  23.  *
  24.  * S001, 01-Jan-93, rickra
  25.  *     Added support for seperate windows.
  26.  *    Added MEM scale routines....
  27.  *
  28.  * S000, 30-Sep-92, rickra
  29.  *     Added copyright and modification history
  30.  *    Change hard coded color referneces to user configurable.
  31.  */
  32. /*+-------------------------------------------------------------------------
  33.     scales.c - XSW CPU and wait percentage scale handler
  34.     wht@n4hgf.Mt-Park.GA.US
  35.  
  36.   Defined functions:
  37.     draw_CpuScale_literals(x,y)
  38.     draw_PctScale_literals(x,y,scale_name,val1_name,val2_name,val3_name)
  39.     draw_WaitScale_literals(x,y)
  40.     update_CpuScale(x,y,per_state)
  41.     update_PctScale(x,y,length,label,totalC,greenC,yellowC,redC)
  42.     update_WaitScale(x,y,per_state,total_ticks)
  43.  
  44. --------------------------------------------------------------------------*/
  45. /*+:EDITS:*/
  46. /*:09-26-1990-00:28-wht@n4hgf-new scale bar labelling */
  47. /*:09-25-1990-05:11-wht@n4hgf-release heh-heh x0.22 preliminary */
  48. /*:09-20-1990-00:09-wht@n4hgf-scales, sysinfo/minfo, bootinfo working */
  49. /*:09-15-1990-14:47-wht-creation */
  50.  
  51. #include "include/unixincs.h"
  52. #include <X11/Xlib.h>
  53. #include <X11/Xutil.h>
  54. #include <X11/Intrinsic.h>
  55. #include <X11/Shell.h>
  56. #include <X11/StringDefs.h>
  57. #include <Xm/Xm.h>
  58. #include <Xm/MainW.h>
  59. #include <Xm/DrawingA.h>
  60.  
  61. #include "include/buttons.h"
  62. #include "include/resources.h"
  63. #include "include/scales.h"
  64. #include "include/xsw.h"
  65.  
  66. extern struct NetworkXswStruct *current_server;
  67.  
  68.  
  69. /*+-------------------------------------------------------------------------
  70.     draw_PctScale_literals(x,y,scale_name,val1_name,val2_name,val3_name)
  71. --------------------------------------------------------------------------*/
  72. void
  73. draw_PctScale_literals1 (window, display, gc, DrawAreaXYWH, x, y, pixmap, scale_name, val1_name, val2_name, val3_name)
  74.      Window          window;
  75.      Display        *display;
  76.      GC              gc;
  77.      XWindowAttributes DrawAreaXYWH;
  78.      int             x;
  79.      int             y;
  80.      Pixmap          pixmap;
  81.      char           *scale_name;
  82.      char           *val1_name;
  83.      char           *val2_name;
  84.      char           *val3_name;
  85. {
  86.   int             x2 = x;
  87.   int             ys = y + FASCENT;
  88.   int             yl1 = y + (FASCENT / 2);
  89.   int             yl2 = y + (FHEIGHT / 2) - 1;
  90.   int             len;
  91.   char           *cptr;
  92.   char            s80[80];
  93.   int             line_style = LineSolid;
  94.   int             cap_style = CapButt;
  95.   int             join_style = JoinMiter;
  96.  
  97. #ifdef DEBUG2
  98.   fprintf (stdout, "In draw_PctScale_literals\n");
  99. #endif
  100.  
  101.  
  102.   /* the "background" color */
  103.   XSetForeground (display, gc, colorTitleBarBG.pixel);
  104.   XSetLineAttributes (display, gc, FHEIGHT - 1,
  105.               line_style, cap_style, join_style);
  106. /*
  107.   XDrawLine (display, window, gc,
  108.          x2, yl2,
  109.          DisplayWidth(display,screen), yl2);
  110. */
  111.   XDrawLine (display, pixmap, gc,
  112.          x2, yl2,
  113.          DisplayWidth (display, screen), yl2);
  114.  
  115.  
  116.  
  117.  
  118.   /* -----CPU ----tot usr ker brk-------------" */
  119.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  120.   XSetLineAttributes (display, gc, FASCENT / 2,
  121.               line_style, cap_style, join_style);
  122. /*
  123.   XDrawLine (display, window, gc,
  124.          x2, yl1,
  125.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  126. */
  127.  
  128.   XDrawLine (display, pixmap, gc,
  129.          x2, yl1,
  130.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  131.  
  132.  
  133.  
  134.   x2 += len;
  135.  
  136.   sprintf (s80, "%-4.4s", scale_name);
  137.   cptr = s80;
  138.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  139. /*
  140.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  141.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  142. */
  143.  
  144.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  145.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  146.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  147.  
  148.  
  149.  
  150.  
  151.   x2 += FWIDTH * len;
  152.  
  153.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  154. /*
  155.   XDrawLine (display, window, gc,
  156.          x2 + FGAP + 1, yl1,
  157.          x2 + (len = (FWIDTH * 4)) - FGAP, yl1);
  158. */
  159.  
  160.   XDrawLine (display, pixmap, gc,
  161.          x2 + FGAP + 1, yl1,
  162.          x2 + (len = (FWIDTH * 4)) - FGAP, yl1);
  163.  
  164.  
  165.  
  166.   x2 += len;
  167.  
  168.   current_server -> PctScale_xoffset = x2 - x;
  169.   sprintf (s80, "tot %s %s %s ", val1_name, val2_name, val3_name);
  170.   cptr = s80;
  171.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  172. /*
  173.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  174.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  175. */
  176.  
  177.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  178.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  179.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  180.  
  181.  
  182.  
  183.   x2 += FWIDTH * len;
  184.  
  185.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  186. /*
  187.   XDrawLine (display, window, gc,
  188.          x2, yl1,
  189.          DisplayWidth(display,screen), yl1);
  190. */
  191.  
  192.   XDrawLine (display, pixmap, gc,
  193.          x2, yl1,
  194.          DisplayWidth (display, screen), yl1);
  195.  
  196.  
  197.   current_server -> PctScale_width = DrawAreaXYWH.width - BORDER_EXTRA_WIDTH - x2;
  198.  
  199.   XSetForeground (display, gc, colorLabel.pixel);
  200.  
  201.   /* per scale labels */
  202. /*
  203.   XClearArea (display, window, x, y + (FHEIGHT * 1), FWIDTH * 13, FHEIGHT, 0);
  204. */
  205.  
  206.   XSetForeground (display, gc, background);
  207.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 1), FWIDTH * 13, FHEIGHT);
  208.  
  209.  
  210.   if ((current_server -> StatCycle_msec >= 100) && (current_server -> StatCycle_msec < 1000L))
  211.     {
  212.       sprintf (s80, "%3d  Ms Avg%% ", (int) (current_server -> StatCycle_msec));
  213.       cptr = s80;
  214.     }
  215.   else
  216.     {
  217.       sprintf (s80, " %2d Sec Avg%% ", (int) (current_server -> StatCycle_msec / 1000L));
  218.       cptr = s80;
  219.     }
  220.  
  221.  
  222.   XSetForeground (display, gc, colorLabel.pixel);
  223. /*
  224.   XDrawString (display, window, gc,
  225.            x, y + (FHEIGHT * 1) + FASCENT,
  226.            cptr, strlen (cptr));
  227. */
  228.  
  229.   XDrawString (display, pixmap, gc,
  230.            x, y + (FHEIGHT * 1) + FASCENT,
  231.            cptr, strlen (cptr));
  232.  
  233.  
  234.  
  235.  
  236. /*
  237.   XClearArea (display, window, x, y + (FHEIGHT * 2), FWIDTH * 13, FHEIGHT, 0);
  238. */
  239.   XSetForeground (display, gc, background);
  240.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 2), FWIDTH * 13, FHEIGHT);
  241.  
  242.  
  243.  
  244.   cptr = s80;
  245.   if (current_server -> StatCycle_msec == 100)
  246.     {
  247.       sprintf (s80, "%3d  Ms Avg%% ", (int) (current_server -> StatCycle_msec * 5));
  248.       cptr = s80;
  249.     }
  250.   else
  251.     {
  252.       sprintf (s80, " %2d Sec Avg%% ", (int) ((current_server -> StatCycle_msec * 5) / 1000L));
  253.       cptr = s80;
  254.     }
  255.  
  256.   XSetForeground (display, gc, colorLabel.pixel);
  257. /*
  258.   XDrawString (display, window, gc,
  259.            x, y + (FHEIGHT * 2) + FASCENT,
  260.            cptr, strlen (cptr));
  261. */
  262.   XDrawString (display, pixmap, gc,
  263.            x, y + (FHEIGHT * 2) + FASCENT,
  264.            cptr, strlen (cptr));
  265.  
  266.  
  267.  
  268. /*
  269.   XClearArea (display, window, x, y + (FHEIGHT * 3), FWIDTH * 13, FHEIGHT, 0);
  270. */
  271.   XSetForeground (display, gc, background);
  272.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 3), FWIDTH * 13, FHEIGHT);
  273.  
  274.  
  275.  
  276.  
  277.   sprintf (s80, " %2d Sec Avg%% ",
  278.        (int) ((current_server -> StatCycle_msec * 10) / 1000L));
  279.   cptr = s80;
  280.  
  281.   XSetForeground (display, gc, colorLabel.pixel);
  282. /*
  283.   XDrawString (display, window, gc,
  284.            x, y + (FHEIGHT * 3) + FASCENT,
  285.            cptr, strlen (cptr));
  286. */
  287.  
  288.   XDrawString (display, pixmap, gc,
  289.            x, y + (FHEIGHT * 3) + FASCENT,
  290.            cptr, strlen (cptr));
  291.  
  292.  
  293.  
  294.  
  295. }                /* end of draw_PctScale_literals */
  296.  
  297. /*+-------------------------------------------------------------------------
  298.     draw_PctScale_literals(x,y,scale_name,val1_name,val2_name,val3_name)
  299. --------------------------------------------------------------------------*/
  300. void
  301. draw_PctScale_literals (x, y, scale_name, val1_name, val2_name, val3_name)
  302.      int             x;
  303.      int             y;
  304.      char           *scale_name;
  305.      char           *val1_name;
  306.      char           *val2_name;
  307.      char           *val3_name;
  308. {
  309.   int             x2 = x;
  310.   int             ys = y + FASCENT;
  311.   int             yl1 = y + (FASCENT / 2);
  312.   int             yl2 = y + (FHEIGHT / 2) - 1;
  313.   int             len;
  314.   char           *cptr;
  315.   char            s80[80];
  316.   int             line_style = LineSolid;
  317.   int             cap_style = CapButt;
  318.   int             join_style = JoinMiter;
  319.  
  320. #ifdef DEBUG2
  321.   fprintf (stdout, "In draw_PctScale_literals\n");
  322. #endif
  323.   /* the "background" color */
  324.   XSetForeground (display, gc, colorTitleBarBG.pixel);
  325.   XSetLineAttributes (display, gc, FHEIGHT - 1,
  326.               line_style, cap_style, join_style);
  327.   XDrawLine (display, window, gc,
  328.          x2, yl2,
  329.          DrawAreaXYWH.width - BORDER_EXTRA_WIDTH, yl2);
  330.  
  331.   /* -----CPU ----tot usr ker brk-------------" */
  332.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  333.   XSetLineAttributes (display, gc, FASCENT / 2,
  334.               line_style, cap_style, join_style);
  335.   XDrawLine (display, window, gc,
  336.          x2, yl1,
  337.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  338.   x2 += len;
  339.  
  340.   sprintf (s80, "%-4.4s", scale_name);
  341.   cptr = s80;
  342.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  343.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  344.   x2 += FWIDTH * len;
  345.  
  346.   XDrawLine (display, window, gc,
  347.          x2 + FGAP + 1, yl1,
  348.          x2 + (len = (FWIDTH * 4)) - FGAP, yl1);
  349.   x2 += len;
  350.  
  351.   current_server -> PctScale_xoffset = x2 - x;
  352.   sprintf (s80, "tot %s %s %s ", val1_name, val2_name, val3_name);
  353.   cptr = s80;
  354.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  355.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  356.   x2 += FWIDTH * len;
  357.  
  358.   XDrawLine (display, window, gc,
  359.          x2, yl1,
  360.          DrawAreaXYWH.width - BORDER_EXTRA_WIDTH, yl1);
  361.  
  362.   current_server -> PctScale_width = DrawAreaXYWH.width - BORDER_EXTRA_WIDTH - x2;
  363.  
  364.   XSetForeground (display, gc, colorLabel.pixel);
  365.  
  366.   /* per scale labels */
  367.   XClearArea (display, window, x, y + (FHEIGHT * 1), FWIDTH * 13, FHEIGHT, 0);
  368.   if ((current_server -> StatCycle_msec >= 100) && (current_server -> StatCycle_msec < 1000L))
  369.     {
  370.       sprintf (s80, "%3d  Ms Avg%% ", (int) (current_server -> StatCycle_msec));
  371.       cptr = s80;
  372.     }
  373.   else
  374.     {
  375.       sprintf (s80, " %2d Sec Avg%% ", (int) (current_server -> StatCycle_msec / 1000L));
  376.       cptr = s80;
  377.     }
  378.   XDrawString (display, window, gc,
  379.            x, y + (FHEIGHT * 1) + FASCENT,
  380.            cptr, strlen (cptr));
  381.  
  382.   XClearArea (display, window, x, y + (FHEIGHT * 2), FWIDTH * 13, FHEIGHT, 0);
  383.   cptr = s80;
  384.   if (current_server -> StatCycle_msec == 100)
  385.     {
  386.       sprintf (s80, "%3d  Ms Avg%% ", (int) (current_server -> StatCycle_msec * 5));
  387.       cptr = s80;
  388.     }
  389.   else
  390.     {
  391.       sprintf (s80, " %2d Sec Avg%% ", (int) ((current_server -> StatCycle_msec * 5) / 1000L));
  392.       cptr = s80;
  393.     }
  394.   XDrawString (display, window, gc,
  395.            x, y + (FHEIGHT * 2) + FASCENT,
  396.            cptr, strlen (cptr));
  397.  
  398.   XClearArea (display, window, x, y + (FHEIGHT * 3), FWIDTH * 13, FHEIGHT, 0);
  399.   sprintf (s80, " %2d Sec Avg%% ", (int) ((current_server -> StatCycle_msec * 10) / 1000L));
  400.   cptr = s80;
  401.   XDrawString (display, window, gc,
  402.            x, y + (FHEIGHT * 3) + FASCENT,
  403.            cptr, strlen (cptr));
  404.  
  405. }                /* end of draw_PctScale_literals */
  406.  
  407. /*+-------------------------------------------------------------------------
  408.     draw_CpuScale_literals(x,y)
  409. --------------------------------------------------------------------------*/
  410. void
  411. draw_CpuScale_literals (SP)
  412.      struct NetworkXswStruct *SP;
  413.  
  414. {
  415.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].window;
  416.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].display;
  417.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].gc;
  418.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].DrawAreaXYWH;
  419.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].pixmap;
  420.  
  421.   int             x = 0;
  422.   int             y = 0;
  423.  
  424.  
  425. #ifdef DEBUG2
  426.   fprintf (stdout, "In draw_CpuScale_literals\n");
  427. #endif
  428.   draw_PctScale_literals1 (window, display, gc, DrawAreaXYWH, x, y, pixmap, "CPU", "usr", "ker", "brk");
  429. }                /* end of draw_CpuScale_literals */
  430.  
  431. /*+-------------------------------------------------------------------------
  432.     draw_WaitScale_literals(x,y)
  433. --------------------------------------------------------------------------*/
  434. void
  435. draw_WaitScale_literals (SP)
  436.      struct NetworkXswStruct *SP;
  437.  
  438. {
  439.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].window;
  440.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].display;
  441.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].gc;
  442.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].DrawAreaXYWH;
  443.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].pixmap;
  444.  
  445.   int             x = 0;
  446.   int             y = 0;
  447.  
  448.  
  449. #ifdef DEBUG2
  450.   fprintf (stdout, "In draw_WaitScale_literals\n");
  451. #endif
  452.  
  453.   draw_PctScale_literals1 (window, display, gc, DrawAreaXYWH, x, y, pixmap, "Wait", " io", "pio", "swp");
  454. }                /* end of draw_WaitScale_literals */
  455.  
  456. /*+-------------------------------------------------------------------------
  457.     update_PctScale(x,y,scale_length,totalC,bar1,bar2,bar3)
  458. --------------------------------------------------------------------------*/
  459. void
  460. update_PctScale (window, display, gc, x, y, scale_length, pixmap, label, totalC, bar1, bar2, bar3, pixel1, pixel2, pixel3)
  461.      Window          window;
  462.      Display        *display;
  463.      GC              gc;
  464.      int             x, y, scale_length;
  465.      Pixmap          pixmap;
  466.      char           *label;
  467.      unsigned long   totalC;
  468.      unsigned long   bar1;
  469.      unsigned long   bar2;
  470.      unsigned long   bar3;
  471.      XColor          pixel1;
  472.      XColor          pixel2;
  473.      XColor          pixel3;
  474.  
  475. {
  476.  
  477.   int             yl = y + (FHEIGHT / 2) - 1;    /* y for lines */
  478.   int             ys = y + FASCENT;    /* y for strings */
  479.   int             line_length;
  480.   int             used_length = 0;
  481.   int             line_style = LineSolid;
  482.   int             cap_style = CapButt;
  483.   int             join_style = JoinMiter;
  484.  
  485. #ifdef DEBUG2
  486.   fprintf (stdout, "In update_PctScale\n");
  487. #endif
  488.  
  489.  
  490. /*
  491.   XClearArea (display, window, x, y - 1, scale_length, FHEIGHT, 0);
  492. */
  493.  
  494.   XSetForeground (display, gc, background);
  495.   XFillRectangle (display, pixmap, gc, x, y - 1, scale_length, FHEIGHT);
  496.  
  497.  
  498.  
  499.   if (scale_length < 6)
  500.     return;
  501.  
  502.   if (totalC < (bar1 + bar2 + bar3))
  503.     totalC = bar1 + bar2 + bar3;
  504.  
  505. /*
  506.  * Proctect against division by ZERO
  507.  */
  508.  
  509.   if (totalC == 0)
  510.     totalC = 1;
  511.  
  512.   XSetLineAttributes (display, gc, FHEIGHT, line_style, cap_style, join_style);
  513.  
  514.   if (line_length = (int) (((float) bar1 * scale_length) / (float) totalC))
  515.     {
  516.       XSetForeground (display, gc, pixel1.pixel);
  517. /*
  518.       XDrawLine (display, window, gc, x, yl, x + line_length, yl);
  519. */
  520.       XDrawLine (display, pixmap, gc, x, yl, x + line_length, yl);
  521.       if (line_length > FWIDTH)
  522.     {
  523.       XSetForeground (display, gc, background);
  524. /*
  525.       XDrawString (display, window, gc, x, ys, label + 0, 1);
  526.       XDrawString (display, window, gc, x + 1, ys, label + 0, 1);
  527. */
  528.  
  529.       XDrawString (display, pixmap, gc, x, ys, label + 0, 1);
  530.       XDrawString (display, pixmap, gc, x + 1, ys, label + 0, 1);
  531.     }
  532.       used_length += line_length;
  533.       x += line_length;
  534.     }
  535.  
  536.   if (line_length = (int) (((float) bar2 * scale_length) / (float) totalC))
  537.     {
  538.       XSetForeground (display, gc, pixel2.pixel);
  539. /*
  540.       XDrawLine (display, window, gc, x, yl, x + line_length, yl);
  541. */
  542.       XDrawLine (display, pixmap, gc, x, yl, x + line_length, yl);
  543.       if (line_length > FWIDTH)
  544.     {
  545.       XSetForeground (display, gc, /* ColorBlack.pixel */ background);
  546. /*
  547.       XDrawString (display, window, gc, x, ys, label + 1, 1);
  548.       XDrawString (display, window, gc, x + 1, ys, label + 1, 1);
  549. */
  550.  
  551.       XDrawString (display, pixmap, gc, x, ys, label + 1, 1);
  552.       XDrawString (display, pixmap, gc, x + 1, ys, label + 1, 1);
  553.     }
  554.       used_length += line_length;
  555.       x += line_length;
  556.     }
  557.  
  558.   if (line_length = (int) (((float) bar3 * scale_length) / (float) totalC))
  559.     {
  560.       XSetForeground (display, gc, pixel3.pixel);
  561. /*
  562.       XDrawLine (display, window, gc, x, yl, x + line_length, yl);
  563. */
  564.       XDrawLine (display, pixmap, gc, x, yl, x + line_length, yl);
  565.       if (line_length > FWIDTH)
  566.     {
  567.       XSetForeground (display, gc, background);
  568. /*
  569.       XDrawString (display, window, gc, x, ys, label + 2, 1);
  570.       XDrawString (display, window, gc, x + 1, ys, label + 2, 1);
  571. */
  572.  
  573.       XDrawString (display, pixmap, gc, x, ys, label + 2, 1);
  574.       XDrawString (display, pixmap, gc, x + 1, ys, label + 2, 1);
  575.     }
  576.       used_length += line_length;
  577.       x += line_length;
  578.     }
  579.  
  580.   if ((scale_length - used_length) > 0)
  581.     {
  582. /*
  583.       XSetForeground (display, gc, background);
  584.       XDrawLine (display, window, gc, x + used_length, yl, x + scale_length, yl);
  585. */
  586.     }
  587.  
  588. }                /* end of update_PctScale */
  589.  
  590. /*+-------------------------------------------------------------------------
  591.     update_CpuScale(x,y,per_state)
  592.  
  593. 000000000011111111112222222222333333333344444444445555555555666666
  594. 012345678901234567890123456789012345678901234567890123456789012345
  595. tot usr ker brk
  596. ### ### ### ### xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  597. extern struct NetworkXswStruct *current_server;
  598. --------------------------------------------------------------------------*/
  599. #define _CPUSCALE_TX    (FWIDTH * 0)
  600. #define _CPUSCALE_UX    (FWIDTH * 4)
  601. #define _CPUSCALE_KX    (FWIDTH * 8)
  602. #define _CPUSCALE_BX    (FWIDTH * 12)
  603. #define _CPUSCALE_SX    (FWIDTH * 16)
  604.  
  605. time_t
  606. update_CpuScale (SP, x, y, per_state)
  607.      struct NetworkXswStruct *SP;
  608.      int             x;
  609.      int             y;
  610.      time_t         *per_state;
  611. {
  612.  
  613.   Widget          shell_widget = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].shell_widget;
  614.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].window;
  615.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].display;
  616.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].gc;
  617.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].DrawAreaXYWH;
  618.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].pixmap;
  619.  
  620.  
  621.   time_t          idle = per_state[CPU_IDLE] + per_state[CPU_WAIT];
  622.   time_t          cpu_ticks_total = idle + per_state[CPU_SXBRK] +
  623.   per_state[CPU_KERNEL] + per_state[CPU_USER];
  624.   unsigned long   pixel;
  625.   char            numstr[8];
  626.   Arg             args[32];
  627.   int             argcount;
  628.  
  629.  
  630.   int             current_width, current_height;
  631.  
  632.   time_t          percent_user = 0;
  633.   time_t          percent_kernel = 0;
  634.   time_t          percent_break = 0;
  635.   time_t          percent_busy = 0;
  636.  
  637.   if (cpu_ticks_total > 0)
  638.     {
  639.       percent_user = (per_state[CPU_USER] * 100) / cpu_ticks_total;
  640.       percent_kernel = (per_state[CPU_KERNEL] * 100) / cpu_ticks_total;
  641.       percent_break = (per_state[CPU_SXBRK] * 100) / cpu_ticks_total;
  642.     }
  643.  
  644.   percent_busy = percent_user + percent_kernel + percent_break;
  645.  
  646.  
  647.   x += current_server -> PctScale_xoffset;
  648.  
  649.  
  650.  
  651.  
  652. /*
  653.  * Clear the area for a new re-draw....
  654.  */
  655.  
  656. /*
  657.   XClearArea (display, window, x, y, FWIDTH * 16, FHEIGHT, 0);
  658. */
  659.  
  660.   XSetForeground (display, gc, background);
  661.   XFillRectangle (display, pixmap, gc, x, y, FWIDTH * 16, FHEIGHT);
  662.  
  663. #if 0
  664.   if (!idle)            /* take care of integer div truncation */
  665.     percent_busy = 100;
  666. #endif
  667.  
  668.   if (percent_busy > res.busyAlarmThreshhold)
  669.     pixel = colorNumericAlarm.pixel;
  670.   else if (percent_busy > res.busyWarningThreshhold)
  671.     pixel = colorNumericWarning.pixel;
  672.   else
  673.     pixel = colorNumeric.pixel;
  674.  
  675.  
  676.  
  677.   XSetForeground (display, gc, pixel);
  678.   sprintf (numstr, "%3ld", percent_busy);
  679. /*
  680.   XDrawString (display, window, gc,
  681.            x + _CPUSCALE_TX, y + FASCENT, numstr, 3);
  682. */
  683.   XDrawString (display, pixmap, gc,
  684.            x + _CPUSCALE_TX, y + FASCENT, numstr, 3);
  685.  
  686.   XSetForeground (display, gc, colorNumeric.pixel);
  687.  
  688.   sprintf (numstr, "%3ld", percent_user);
  689. /*
  690.   XDrawString (display, window, gc,
  691.            x + _CPUSCALE_UX, y + FASCENT, numstr, 3);
  692. */
  693.   XDrawString (display, pixmap, gc,
  694.            x + _CPUSCALE_UX, y + FASCENT, numstr, 3);
  695.  
  696.   sprintf (numstr, "%3ld", percent_kernel);
  697. /*
  698.   XDrawString (display, window, gc,
  699.            x + _CPUSCALE_KX, y + FASCENT, numstr, 3);
  700. */
  701.   XDrawString (display, pixmap, gc,
  702.            x + _CPUSCALE_KX, y + FASCENT, numstr, 3);
  703.  
  704.   if (percent_break > res.breakAlarmThreshhold)
  705.     XSetForeground (display, gc, colorNumericAlarm.pixel);
  706.   else if (percent_break > res.breakWarningThreshhold)
  707.     XSetForeground (display, gc, colorNumericWarning.pixel);
  708.  
  709.   sprintf (numstr, "%3ld", percent_break);
  710. /*
  711.   XDrawString (display, window, gc,
  712.            x + _CPUSCALE_BX, y + FASCENT, numstr, 3);
  713. */
  714.   XDrawString (display, pixmap, gc,
  715.            x + _CPUSCALE_BX, y + FASCENT, numstr, 3);
  716.  
  717.  
  718. /*
  719.  * We need to draw the scale to the viewing port, Thus we need to find
  720.  * the "current" width of the shell widget.....
  721.  *
  722.  * Perhaps, when we create the pixmap to the actual size needed, we can
  723.  * look at the Drawing Areaing Width,Height parameters......
  724.  */
  725.  
  726.   current_width = current_server -> SEPERATE_WINDOWS_LIST[BUTTON_cpu].width;
  727.  
  728.   update_PctScale (window, display, gc, x + _CPUSCALE_SX, y,
  729.            current_width - (x + _CPUSCALE_SX),
  730.            pixmap,
  731.            "ukb", 100,
  732.            percent_user, percent_kernel, percent_break,
  733.            colorUser, colorKernel, colorBreak);
  734.  
  735.  
  736. #ifdef DEBUG2
  737.   fprintf (stdout, "leaving update_CpuScale\n");
  738. #endif
  739.  
  740.   return (cpu_ticks_total);
  741.  
  742. }                /* end of update_CpuScale */
  743.  
  744. /*+-------------------------------------------------------------------------
  745.     update_WaitScale(x,y,per_state,total_ticks)
  746.  
  747. 000000000011111111112222222222333333333344444444445555555555666666
  748. 012345678901234567890123456789012345678901234567890123456789012345
  749. tot  io pio swp
  750. ### ### ### ### xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  751. --------------------------------------------------------------------------*/
  752. #define _WAITSCALE_TX    (FWIDTH * 0)
  753. #define _WAITSCALE_IX    (FWIDTH * 4)
  754. #define _WAITSCALE_PX    (FWIDTH * 8)
  755. #define _WAITSCALE_WX    (FWIDTH * 12)
  756. #define _WAITSCALE_SX    (FWIDTH * 16)
  757.  
  758. void
  759. update_WaitScale (SP, x, y, total_ticks)
  760.      struct NetworkXswStruct *SP;
  761.      int             x;
  762.      int             y;
  763.      time_t          total_ticks;
  764.  
  765. {
  766.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].window;
  767.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].display;
  768.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].gc;
  769.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].pixmap;
  770.   XWindowAttributes DrawAreaXYWH =
  771.   SP -> SEPERATE_WINDOWS_LIST[BUTTON_wait].DrawAreaXYWH;
  772.  
  773.   time_t         *per_state = SP -> wait_ticks;
  774.  
  775.   int             current_width, current_height;
  776.  
  777.  
  778.   int             accum = 0;
  779.   time_t          percent_io = 0L;
  780.   time_t          percent_swap = 0L;
  781.   time_t          percent_pio = 0L;
  782.   time_t          percent_total_wait;
  783.   time_t          total_wait;
  784.   unsigned long   pixel;
  785.   char            numstr[8];
  786.  
  787.  
  788.   x += current_server -> PctScale_xoffset;
  789.  
  790.   /* crock: because of latency, total_ticks < all wait ticks sometimes */
  791.   total_wait = per_state[W_IO] + per_state[W_SWAP] + per_state[W_PIO];
  792.   if (total_ticks < total_wait)
  793.     total_ticks = total_wait;
  794.  
  795.   if (total_ticks)
  796.     {
  797.       percent_io = (per_state[W_IO] * 100) / total_ticks;
  798.       percent_pio = (per_state[W_PIO] * 100) / total_ticks;
  799.       percent_swap = (per_state[W_SWAP] * 100) / total_ticks;
  800.     }
  801.   percent_total_wait = percent_io + percent_swap + percent_pio;
  802. /*
  803.   XClearArea (display, window, x, y, FWIDTH * 16, FHEIGHT, 0);
  804. */
  805.  
  806.   XSetForeground (display, gc, background);
  807.   XFillRectangle (display, pixmap, gc, x, y, FWIDTH * 16, FHEIGHT);
  808.  
  809.  
  810.   if (percent_total_wait > res.waitAlarmThreshhold)
  811.     pixel = colorNumericAlarm.pixel;
  812.   else if (percent_total_wait > res.waitWarningThreshhold)
  813.     pixel = colorNumericWarning.pixel;
  814.   else
  815.     pixel = colorNumeric.pixel;
  816.  
  817.   XSetForeground (display, gc, pixel);
  818.   sprintf (numstr, "%3ld", percent_total_wait);
  819. /*
  820.   XDrawString (display, window, gc,
  821.            x + _WAITSCALE_TX, y + FASCENT, numstr, 3);
  822. */
  823.   XDrawString (display, pixmap, gc,
  824.            x + _WAITSCALE_TX, y + FASCENT, numstr, 3);
  825.  
  826.   XSetForeground (display, gc, colorNumeric.pixel);
  827.  
  828.   sprintf (numstr, "%3ld", percent_io);
  829. /*
  830.   XDrawString (display, window, gc,
  831.            x + _WAITSCALE_IX, y + FASCENT, numstr, 3);
  832. */
  833.   XDrawString (display, pixmap, gc,
  834.            x + _WAITSCALE_IX, y + FASCENT, numstr, 3);
  835.  
  836.   sprintf (numstr, "%3ld", percent_pio);
  837. /*
  838.   XDrawString (display, window, gc,
  839.            x + _WAITSCALE_PX, y + FASCENT, numstr, 3);
  840. */
  841.   XDrawString (display, pixmap, gc,
  842.            x + _WAITSCALE_PX, y + FASCENT, numstr, 3);
  843.  
  844.   if (percent_swap > res.swapAlarmThreshhold)
  845.     XSetForeground (display, gc, colorNumericAlarm.pixel);
  846.   else if (percent_swap > res.swapWarningThreshhold)
  847.     XSetForeground (display, gc, colorNumericWarning.pixel);
  848.  
  849.   sprintf (numstr, "%3ld", percent_swap);
  850. /*
  851.   XDrawString (display, window, gc,
  852.            x + _WAITSCALE_WX, y + FASCENT, numstr, 3);
  853. */
  854.   XDrawString (display, pixmap, gc,
  855.            x + _WAITSCALE_WX, y + FASCENT, numstr, 3);
  856.   current_width = current_server -> SEPERATE_WINDOWS_LIST[BUTTON_wait].width;
  857.  
  858.  
  859.   update_PctScale (window, display, gc, x + _WAITSCALE_SX, y,
  860.            current_width - (x + _WAITSCALE_SX),
  861.            pixmap,
  862.            "ips", 100,
  863.            percent_io, percent_pio, percent_swap,
  864.            colorIo, colorPio, colorSwap);
  865.  
  866. }                /* end of update_WaitScale */
  867.  
  868.  
  869. /*+-------------------------------------------------------------------------
  870.  draw_Single_PctScale_literals(x,y,scale_name,val1_name,val2_name,val3_name)
  871. --------------------------------------------------------------------------*/
  872. void
  873. draw_Single_PctScale_literals (window, display, gc, DrawAreaXYWH, pixmap, x, y, scale_name, val1_name, val2_name, val3_name)
  874.      Window          window;
  875.      Display        *display;
  876.      GC              gc;
  877.      XWindowAttributes DrawAreaXYWH;
  878.      Pixmap          pixmap;
  879.  
  880.      int             x;
  881.      int             y;
  882.      char           *scale_name;
  883.      char           *val1_name;
  884.      char           *val2_name;
  885.      char           *val3_name;
  886. {
  887.   int             x2 = x;
  888.   int             ys = y + FASCENT;
  889.   int             yl1 = y + (FASCENT / 2);
  890.   int             yl2 = y + (FHEIGHT / 2) - 1;
  891.   int             len;
  892.   char           *cptr;
  893.   char            s80[80];
  894.   int             line_style = LineSolid;
  895.   int             cap_style = CapButt;
  896.   int             join_style = JoinMiter;
  897.  
  898. #ifdef DEBUG2
  899.   fprintf (stdout, "In draw_Single_PctScale_literals\n");
  900. #endif
  901.  
  902.  
  903.   /* the "background" color */
  904.   XSetForeground (display, gc, colorTitleBarBG.pixel);
  905.   XSetLineAttributes (display, gc, FHEIGHT - 1,
  906.               line_style, cap_style, join_style);
  907. /*
  908.   XDrawLine (display, window, gc,
  909.          x2, yl2,
  910.          DrawAreaXYWH.width - BORDER_EXTRA_WIDTH, yl2);
  911. */
  912.   XDrawLine (display, pixmap, gc,
  913.          x2, yl2,
  914.          current_server -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - BORDER_EXTRA_WIDTH, yl2);
  915.  
  916.   /* -----Other---cnfg max curr-------------" */
  917.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  918.   XSetLineAttributes (display, gc, FASCENT / 2,
  919.               line_style, cap_style, join_style);
  920. /*
  921.   XDrawLine (display, window, gc,
  922.          x2, yl1,
  923.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  924. */
  925.   XDrawLine (display, pixmap, gc,
  926.          x2, yl1,
  927.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  928.   x2 += len;
  929.  
  930.   sprintf (s80, "%-5.5s", scale_name);
  931.   cptr = s80;
  932. /*
  933.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  934.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  935. */
  936.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  937.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  938.   x2 += FWIDTH * len;
  939.  
  940. /*
  941.   XDrawLine (display, window, gc,
  942.          x2 + FGAP + 1, yl1,
  943.          x2 + (len = (FWIDTH * 3)) - FGAP, yl1);
  944. */
  945.   XDrawLine (display, pixmap, gc,
  946.          x2 + FGAP + 1, yl1,
  947.          x2 + (len = (FWIDTH * 3)) - FGAP, yl1);
  948.   x2 += len;
  949.  
  950.   current_server -> PctScale_xoffset = x2 - x;
  951.   sprintf (s80, " %s  %s %s ", val1_name, val2_name, val3_name);
  952.   cptr = s80;
  953. /*
  954.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  955.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  956. */
  957.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  958.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  959.   x2 += FWIDTH * len;
  960.  
  961. /*
  962.   XDrawLine (display, window, gc,
  963.          x2, yl1,
  964.          DrawAreaXYWH.width - BORDER_EXTRA_WIDTH, yl1);
  965. */
  966.   XDrawLine (display, pixmap, gc,
  967.          x2, yl1,
  968.          current_server -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - BORDER_EXTRA_WIDTH, yl1);
  969.   current_server -> PctScale_width = current_server -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - BORDER_EXTRA_WIDTH - x2;
  970.  
  971.   XSetForeground (display, gc, colorLabel.pixel);
  972.  
  973. /* Need to change this , I.e. make into a function ?? */
  974. /*
  975.   XClearArea (display, window, x, y + (FHEIGHT * 1), FWIDTH * 12, FHEIGHT, 0);
  976. */
  977.  
  978.   XSetForeground (display, gc, background);
  979.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 1), FWIDTH * 12, FHEIGHT);
  980.   XSetForeground (display, gc, colorLabel.pixel);
  981.   cptr = " NFILES     ";
  982. /*
  983.   XDrawString (display, window, gc,
  984.            x, y + (FHEIGHT * 1) + FASCENT,
  985.            cptr, strlen (cptr));
  986. */
  987.   XDrawString (display, pixmap, gc,
  988.            x, y + (FHEIGHT * 1) + FASCENT,
  989.            cptr, strlen (cptr));
  990. /*
  991.   XClearArea (display, window, x, y + (FHEIGHT * 2), FWIDTH * 12, FHEIGHT, 0);
  992. */
  993.   XSetForeground (display, gc, background);
  994.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 2), FWIDTH * 12, FHEIGHT);
  995.   XSetForeground (display, gc, colorLabel.pixel);
  996.   cptr = " NINODES    ";
  997. /*
  998.   XDrawString (display, window, gc,
  999.            x, y + (FHEIGHT * 2) + FASCENT,
  1000.            cptr, strlen (cptr));
  1001. */
  1002.   XDrawString (display, pixmap, gc,
  1003.            x, y + (FHEIGHT * 2) + FASCENT,
  1004.            cptr, strlen (cptr));
  1005.  
  1006. /*
  1007.   XClearArea (display, window, x, y + (FHEIGHT * 3), FWIDTH * 12, FHEIGHT, 0);
  1008. */
  1009.   XSetForeground (display, gc, background);
  1010.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 3), FWIDTH * 12, FHEIGHT);
  1011.   XSetForeground (display, gc, colorLabel.pixel);
  1012.   cptr = " NPROCS     ";
  1013. /*
  1014.   XDrawString (display, window, gc,
  1015.            x, y + (FHEIGHT * 3) + FASCENT,
  1016.            cptr, strlen (cptr));
  1017. */
  1018.   XDrawString (display, pixmap, gc,
  1019.            x, y + (FHEIGHT * 3) + FASCENT,
  1020.            cptr, strlen (cptr));
  1021. /*
  1022.   XClearArea (display, window, x, y + (FHEIGHT * 4), FWIDTH * 12, FHEIGHT, 0);
  1023. */
  1024.   XSetForeground (display, gc, background);
  1025.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 4), FWIDTH * 12, FHEIGHT);
  1026.   XSetForeground (display, gc, colorLabel.pixel);
  1027.   cptr = " NREGIONS   ";
  1028. /*
  1029.   XDrawString (display, window, gc,
  1030.            x, y + (FHEIGHT * 4) + FASCENT,
  1031.            cptr, strlen (cptr));
  1032. */
  1033.   XDrawString (display, pixmap, gc,
  1034.            x, y + (FHEIGHT * 4) + FASCENT,
  1035.            cptr, strlen (cptr));
  1036.  
  1037.  
  1038. /*
  1039.   XClearArea (display, window, x, y + (FHEIGHT * 5), FWIDTH * 12, FHEIGHT, 0);
  1040. */
  1041.   XSetForeground (display, gc, background);
  1042.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 5), FWIDTH * 12, FHEIGHT);
  1043.   XSetForeground (display, gc, colorLabel.pixel);
  1044.   cptr = " CBLOCKS    ";
  1045. /*
  1046.   XDrawString (display, window, gc,
  1047.            x, y + (FHEIGHT * 5) + FASCENT,
  1048.            cptr, strlen (cptr));
  1049. */
  1050.   XDrawString (display, pixmap, gc,
  1051.            x, y + (FHEIGHT * 5) + FASCENT,
  1052.            cptr, strlen (cptr));
  1053.  
  1054. /*
  1055.   XClearArea (display, window, x, y + (FHEIGHT * 6), FWIDTH * 12, FHEIGHT, 0);
  1056. */
  1057.   XSetForeground (display, gc, background);
  1058.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 6), FWIDTH * 12, FHEIGHT);
  1059.   XSetForeground (display, gc, colorLabel.pixel);
  1060.   cptr = " CALLOUTS   ";
  1061. /*
  1062.   XDrawString (display, window, gc,
  1063.            x, y + (FHEIGHT * 6) + FASCENT,
  1064.            cptr, strlen (cptr));
  1065. */
  1066.   XDrawString (display, pixmap, gc,
  1067.            x, y + (FHEIGHT * 6) + FASCENT,
  1068.            cptr, strlen (cptr));
  1069.  
  1070. /*
  1071.   XClearArea (display, window, x, y + (FHEIGHT * 7), FWIDTH * 12, FHEIGHT, 0);
  1072. */
  1073.   XSetForeground (display, gc, background);
  1074.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 7), FWIDTH * 12, FHEIGHT);
  1075.   XSetForeground (display, gc, colorLabel.pixel);
  1076.   cptr = " NMOUNTS    ";
  1077. /*
  1078.   XDrawString (display, window, gc,
  1079.            x, y + (FHEIGHT * 7) + FASCENT,
  1080.            cptr, strlen (cptr));
  1081. */
  1082.   XDrawString (display, pixmap, gc,
  1083.            x, y + (FHEIGHT * 7) + FASCENT,
  1084.            cptr, strlen (cptr));
  1085. }                /* end of draw_Single_PctScale_literals */
  1086.  
  1087.  
  1088. /*+-------------------------------------------------------------------------
  1089.  draw_Mem_PctScale_literals(x,y,scale_name,val1_name,val2_name,val3_name)
  1090. --------------------------------------------------------------------------*/
  1091. void
  1092. draw_Mem_PctScale_literals (window, display, gc, DrawAreaXYWH, pixmap, x, y, scale_name, val1_name, val2_name)
  1093.      Window          window;
  1094.      Display        *display;
  1095.      GC              gc;
  1096.      XWindowAttributes DrawAreaXYWH;
  1097.      Pixmap          pixmap;
  1098.      int             x;
  1099.      int             y;
  1100.      char           *scale_name;
  1101.      char           *val1_name;
  1102.      char           *val2_name;
  1103. {
  1104.   int             x2 = x;
  1105.   int             ys = y + FASCENT;
  1106.   int             yl1 = y + (FASCENT / 2);
  1107.   int             yl2 = y + (FHEIGHT / 2) - 1;
  1108.   int             len;
  1109.   char           *cptr;
  1110.   char            s80[80];
  1111.   int             line_style = LineSolid;
  1112.   int             cap_style = CapButt;
  1113.   int             join_style = JoinMiter;
  1114.  
  1115. #ifdef DEBUG2
  1116.   fprintf (stdout, "In draw_Mem_PctScale_literals\n");
  1117. #endif
  1118.  
  1119.  
  1120.   /* the "background" color */
  1121.   XSetForeground (display, gc, colorTitleBarBG.pixel);
  1122.   XSetLineAttributes (display, gc, FHEIGHT - 1,
  1123.               line_style, cap_style, join_style);
  1124. /*
  1125.   XDrawLine (display, window, gc,
  1126.          x2, yl2,
  1127.          DrawAreaXYWH.width - BORDER_EXTRA_WIDTH, yl2);
  1128. */
  1129.   XDrawLine (display, pixmap, gc,
  1130.          x2, yl2,
  1131.          current_server -> SEPERATE_WINDOWS_LIST[BUTTON_mem].width - BORDER_EXTRA_WIDTH, yl2);
  1132.  
  1133.   /* -----Cache---     max curr-------------" */
  1134.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  1135.   XSetLineAttributes (display, gc, FASCENT / 2,
  1136.               line_style, cap_style, join_style);
  1137. /*
  1138.   XDrawLine (display, window, gc,
  1139.          x2, yl1,
  1140.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  1141. */
  1142.   XDrawLine (display, pixmap, gc,
  1143.          x2, yl1,
  1144.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  1145.   x2 += len;
  1146.  
  1147.   sprintf (s80, "%-6.6s", scale_name);
  1148.   cptr = s80;
  1149. /*
  1150.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  1151.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  1152. */
  1153.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  1154.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  1155.   x2 += FWIDTH * len;
  1156. /*
  1157.   XDrawLine (display, window, gc,
  1158.          x2 + FGAP + 1, yl1,
  1159.          x2 + (len = (FWIDTH * 8)) - FGAP, yl1);
  1160. */
  1161.   XDrawLine (display, pixmap, gc,
  1162.          x2 + FGAP + 1, yl1,
  1163.          x2 + (len = (FWIDTH * 8)) - FGAP, yl1);
  1164.   x2 += len;
  1165.  
  1166. /* need to ajust PctScale_xoffset to conform to the other routiunes..... */
  1167.  
  1168.   sprintf (s80, " %s %s ", val1_name, val2_name);
  1169.   cptr = s80;
  1170. /*
  1171.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  1172.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  1173. */
  1174.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  1175.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  1176.   x2 += FWIDTH * len;
  1177.  
  1178. /*
  1179.   XDrawLine (display, window, gc,
  1180.          x2, yl1,
  1181.          SP->SEPERATE_WINDOWS_LIST[BUTTON_mem].width - BORDER_EXTRA_WIDTH, yl1);
  1182. */
  1183.   XDrawLine (display, pixmap, gc,
  1184.          x2, yl1,
  1185.          current_server -> SEPERATE_WINDOWS_LIST[BUTTON_mem].width - BORDER_EXTRA_WIDTH, yl1);
  1186.  
  1187.  
  1188. /* Need to change this , I.e. make into a function ?? */
  1189.  
  1190. /*
  1191.   XSetForeground (display, gc, colorLabel.pixel);
  1192.   XClearArea (display, window, x, y + (FHEIGHT * 1), FWIDTH * 12, FHEIGHT, 0);
  1193. */
  1194.   XSetForeground (display, gc, background);
  1195.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 1), FWIDTH * 12, FHEIGHT);
  1196.  
  1197.   XSetForeground (display, gc, colorLabel.pixel);
  1198.  
  1199.   cptr = " % Memory Used     ";
  1200. /*
  1201.   XDrawString (display, window, gc,
  1202.            x, y + (FHEIGHT * 1) + FASCENT,
  1203.            cptr, strlen (cptr));
  1204. */
  1205.   XDrawString (display, pixmap, gc,
  1206.            x, y + (FHEIGHT * 1) + FASCENT,
  1207.            cptr, strlen (cptr));
  1208. /*
  1209.   XClearArea (display, window, x, y + (FHEIGHT * 2), FWIDTH * 12, FHEIGHT, 0);
  1210. */
  1211.   XSetForeground (display, gc, background);
  1212.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 2), FWIDTH * 12, FHEIGHT);
  1213.  
  1214.   XSetForeground (display, gc, colorLabel.pixel);
  1215.  
  1216.   cptr = " % Swap Used       ";
  1217. /*
  1218.   XDrawString (display, window, gc,
  1219.            x, y + (FHEIGHT * 2) + FASCENT,
  1220.            cptr, strlen (cptr));
  1221. */
  1222.   XDrawString (display, pixmap, gc,
  1223.            x, y + (FHEIGHT * 2) + FASCENT,
  1224.            cptr, strlen (cptr));
  1225. /*
  1226.   XClearArea (display, window, x, y + (FHEIGHT * 3), FWIDTH * 12, FHEIGHT, 0);
  1227. */
  1228.   XSetForeground (display, gc, background);
  1229.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 3), FWIDTH * 12, FHEIGHT);
  1230.  
  1231.   XSetForeground (display, gc, colorLabel.pixel);
  1232.   cptr = " % Avail. Swap Used";
  1233. /*
  1234.   XDrawString (display, window, gc,
  1235.            x, y + (FHEIGHT * 3) + FASCENT,
  1236.            cptr, strlen (cptr));
  1237. */
  1238.   XDrawString (display, pixmap, gc,
  1239.            x, y + (FHEIGHT * 3) + FASCENT,
  1240.            cptr, strlen (cptr));
  1241.  
  1242. }                /* end of draw_Mem_PctScale_literals */
  1243.  
  1244. /*+-------------------------------------------------------------------------
  1245.  draw_Cache_PctScale_literals(x,y,scale_name,val1_name,val2_name,val3_name)
  1246. --------------------------------------------------------------------------*/
  1247. void
  1248. draw_Cache_PctScale_literals (window, display, gc, DrawAreaXYWH, x, y, pixmap, scale_name, val1_name, val2_name, val3_name)
  1249.      Window          window;
  1250.      Display        *display;
  1251.      GC              gc;
  1252.      XWindowAttributes DrawAreaXYWH;
  1253.      int             x;
  1254.      int             y;
  1255.      char           *scale_name;
  1256.      char           *val1_name;
  1257.      char           *val2_name;
  1258.      char           *val3_name;
  1259. {
  1260.   int             x2 = x;
  1261.   int             ys = y + FASCENT;
  1262.   int             yl1 = y + (FASCENT / 2);
  1263.   int             yl2 = y + (FHEIGHT / 2) - 1;
  1264.   int             len;
  1265.   char           *cptr;
  1266.   char            s80[80];
  1267.   int             line_style = LineSolid;
  1268.   int             cap_style = CapButt;
  1269.   int             join_style = JoinMiter;
  1270.  
  1271. #ifdef DEBUG2
  1272.   fprintf (stdout, "In draw_Cache_PctScale_literals\n");
  1273. #endif
  1274.  
  1275.  
  1276.   /* the "background" color */
  1277.   XSetForeground (display, gc, colorTitleBarBG.pixel);
  1278.   XSetLineAttributes (display, gc, FHEIGHT - 1,
  1279.               line_style, cap_style, join_style);
  1280. /*
  1281.   XDrawLine (display, window, gc,
  1282.          x2, yl2,
  1283.          DrawAreaXYWH.width - BORDER_EXTRA_WIDTH, yl2);
  1284. */
  1285.   XDrawLine (display, pixmap, gc,
  1286.          x2, yl2,
  1287.       current_server -> SEPERATE_WINDOWS_LIST[BUTTON_cache].width, yl2);
  1288.  
  1289.   /* -----Cache---     max curr-------------" */
  1290.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  1291.   XSetLineAttributes (display, gc, FASCENT / 2,
  1292.               line_style, cap_style, join_style);
  1293. /*
  1294.   XDrawLine (display, window, gc,
  1295.          x2, yl1,
  1296.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  1297. */
  1298.   XDrawLine (display, pixmap, gc,
  1299.          x2, yl1,
  1300.          x2 + (len = (FWIDTH * 5)) - FGAP, yl1);
  1301.   x2 += len;
  1302.  
  1303.   sprintf (s80, "%-5.5s", scale_name);
  1304.   cptr = s80;
  1305. /*
  1306.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  1307.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  1308. */
  1309.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  1310.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  1311.   x2 += FWIDTH * len;
  1312. /*
  1313.   XDrawLine (display, window, gc,
  1314.          x2 + FGAP + 1, yl1,
  1315.          x2 + (len = (FWIDTH * 9)) - FGAP, yl1);
  1316. */
  1317.   XDrawLine (display, pixmap, gc,
  1318.          x2 + FGAP + 1, yl1,
  1319.          x2 + (len = (FWIDTH * 9)) - FGAP, yl1);
  1320.   x2 += len;
  1321.  
  1322. /* need to ajust PctScale_xoffset to conform to the other routiunes..... */
  1323.  
  1324.   current_server -> PctScale_xoffset = x2 - (FWIDTH * 6) - x;
  1325.   sprintf (s80, " %s %s ", val2_name, val3_name);
  1326.   cptr = s80;
  1327. /*
  1328.   XDrawString (display, window, gc, x2, ys, cptr, len = strlen (cptr));
  1329.   XDrawString (display, window, gc, x2 + 1, ys, cptr, len);
  1330. */
  1331.   XDrawString (display, pixmap, gc, x2, ys, cptr, len = strlen (cptr));
  1332.   XDrawString (display, pixmap, gc, x2 + 1, ys, cptr, len);
  1333.   x2 += FWIDTH * len;
  1334. /*
  1335.   XDrawLine (display, window, gc,
  1336.          x2, yl1,
  1337.          DrawAreaXYWH.width - BORDER_EXTRA_WIDTH, yl1);
  1338. */
  1339.   XDrawLine (display, pixmap, gc,
  1340.          x2, yl1,
  1341.       current_server -> SEPERATE_WINDOWS_LIST[BUTTON_cache].width, yl1);
  1342.  
  1343.   XSetForeground (display, gc, colorLabel.pixel);
  1344.  
  1345. /* Need to change this , I.e. make into a function ?? */
  1346.  
  1347. /*
  1348.   XClearArea (display, window, x, y + (FHEIGHT * 1), FWIDTH * 12, FHEIGHT, 0);
  1349. */
  1350.   XSetForeground (display, gc, background);
  1351.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 1), FWIDTH * 12, FHEIGHT);
  1352.  
  1353.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  1354.   cptr = " % WRITE HIT";
  1355. /*
  1356.   XDrawString (display, window, gc,
  1357.            x, y + (FHEIGHT * 1) + FASCENT,
  1358.            cptr, strlen (cptr));
  1359. */
  1360.   XDrawString (display, pixmap, gc,
  1361.            x, y + (FHEIGHT * 1) + FASCENT,
  1362.            cptr, strlen (cptr));
  1363. /*
  1364.   XClearArea (display, window, x, y + (FHEIGHT * 2), FWIDTH * 12, FHEIGHT, 0);
  1365. */
  1366.   XSetForeground (display, gc, background);
  1367.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 2), FWIDTH * 12, FHEIGHT);
  1368.  
  1369.   XSetForeground (display, gc, colorTitleBarFG.pixel);
  1370.   cptr = " % READ HIT ";
  1371. /*
  1372.   XDrawString (display, window, gc,
  1373.            x, y + (FHEIGHT * 2) + FASCENT,
  1374.            cptr, strlen (cptr));
  1375. */
  1376.   XDrawString (display, pixmap, gc,
  1377.            x, y + (FHEIGHT * 2) + FASCENT,
  1378.            cptr, strlen (cptr));
  1379.  
  1380. }                /* end of draw_Cache_PctScale_literals */
  1381.  
  1382. /*+-------------------------------------------------------------------------
  1383.     draw_OtherScale_literals(x,y)
  1384. --------------------------------------------------------------------------*/
  1385. void
  1386. draw_OtherScale_literals (SP)
  1387.  
  1388.      struct NetworkXswStruct *SP;
  1389.  
  1390. {
  1391.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].window;
  1392.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].display;
  1393.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].gc;
  1394.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].DrawAreaXYWH;
  1395.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].pixmap;
  1396.  
  1397.   int             x = 0;
  1398.   int             y = 0;
  1399.  
  1400. #ifdef DEBUG2
  1401.   fprintf (stdout, "In draw_OtherScale_literals\n");
  1402. #endif
  1403.   draw_Single_PctScale_literals (window, display, gc, DrawAreaXYWH, pixmap, x, y, "Other", "cnfg", "max", "curr");
  1404. }                /* end of draw_OtherScale_literals */
  1405.  
  1406. /*+-------------------------------------------------------------------------
  1407.     draw_CacheScale_literals(x,y)
  1408. --------------------------------------------------------------------------*/
  1409. void
  1410. draw_CacheScale_literals (SP)
  1411.      struct NetworkXswStruct *SP;
  1412. {
  1413.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].window;
  1414.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].display;
  1415.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].gc;
  1416.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].DrawAreaXYWH;
  1417.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].pixmap;
  1418.  
  1419.   int             x = 0;
  1420.   int             y = 0;
  1421.  
  1422.  
  1423. #ifdef DEBUG2
  1424.   fprintf (stdout, "In draw_CacheScale_literals\n");
  1425. #endif
  1426.   draw_Cache_PctScale_literals (window, display, gc, DrawAreaXYWH, x, y, pixmap, "Cache", "    ", "avg", "curr");
  1427. }                /* end of draw_OtherScale_literals */
  1428.  
  1429.  
  1430. /*+-------------------------------------------------------------------------
  1431.     draw_MemScale_literals(x,y)
  1432. --------------------------------------------------------------------------*/
  1433. void
  1434. draw_MemScale_literals (SP)
  1435.      struct NetworkXswStruct *SP;
  1436. {
  1437.  
  1438.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].window;
  1439.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].display;
  1440.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].gc;
  1441.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].DrawAreaXYWH;
  1442.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].pixmap;
  1443.  
  1444.   int             x = 0;
  1445.   int             y = 0;
  1446. #ifdef DEBUG2
  1447.   fprintf (stdout, "In draw_MemScale_literals\n");
  1448. #endif
  1449.   draw_Mem_PctScale_literals (window, display, gc, DrawAreaXYWH, pixmap, x, y, "Memory",
  1450.                   "avg", "curr");
  1451. }                /* end of draw_OtherScale_literals */
  1452.  
  1453.  
  1454.  
  1455.  
  1456. /*+-------------------------------------------------------------------------
  1457.     update_Single_PctScale(x,y,scale_length,totalC,greenC)
  1458. --------------------------------------------------------------------------*/
  1459. void
  1460. update_Single_PctScale (window, display, gc, DrawAreaXYWH, pixmap, x, y, scale_length, label, totalC, greenC, pixel)
  1461.      Window          window;
  1462.      Display        *display;
  1463.      GC              gc;
  1464.      XWindowAttributes DrawAreaXYWH;
  1465.      Pixmap          pixmap;
  1466.      int             x, y, scale_length;
  1467.      char           *label;
  1468.      long            totalC;
  1469.      long            greenC;
  1470.      unsigned long   pixel;
  1471. {
  1472.   int             yl = y + (FHEIGHT / 2) - 1;    /* y for lines */
  1473.   int             ys = y + FASCENT;    /* y for strings */
  1474.   int             line_length;
  1475.   int             used_length = 0;
  1476.   int             line_style = LineSolid;
  1477.   int             cap_style = CapButt;
  1478.   int             join_style = JoinMiter;
  1479. #ifdef DEBUG2
  1480.   fprintf (stdout, "In update_Single_PctScale\n");
  1481. #endif
  1482. /*
  1483.   XClearArea (display, window, x, y - 1, scale_length, FHEIGHT, 0);
  1484. */
  1485.   XSetForeground (display, gc, background);
  1486.   XFillRectangle (display, pixmap, gc, x, y - 1, scale_length, FHEIGHT);
  1487.  
  1488.   if (scale_length < 6)
  1489.     return;
  1490.  
  1491.   XSetLineAttributes (display, gc, FHEIGHT, line_style, cap_style, join_style);
  1492.  
  1493. /*
  1494.  * Protect againts divsion by ZERO....
  1495.  */
  1496.  
  1497.   if (totalC == 0)
  1498.     totalC = 1;
  1499.  
  1500.   if (line_length = (int) (((float) greenC * scale_length) / (float) totalC))
  1501.     {
  1502.       XSetForeground (display, gc, pixel);
  1503. /*
  1504.       XDrawLine (display, window, gc, x, yl, x + line_length, yl);
  1505. */
  1506.       XDrawLine (display, pixmap, gc, x, yl, x + line_length, yl);
  1507.       if (line_length > FWIDTH)
  1508.     {
  1509. /*
  1510.       XSetForeground (display, gc, background);
  1511. */
  1512. /*
  1513.       XDrawString (display, window, gc, x, ys, label + 0, 1);
  1514.       XDrawString (display, window, gc, x + 1, ys, label + 0, 1);
  1515. */
  1516.       XDrawString (display, pixmap, gc, x, ys, label + 0, 1);
  1517.       XDrawString (display, pixmap, gc, x + 1, ys, label + 0, 1);
  1518.     }
  1519.       used_length += line_length;
  1520.       x += line_length;
  1521.     }
  1522.  
  1523.   if ((scale_length - used_length) > 0)
  1524.     {
  1525. /*
  1526.       XSetForeground (display, gc, background);
  1527.       XDrawLine (display, window, gc, x + used_length, yl, x + scale_length, yl);
  1528. */
  1529.     }
  1530.  
  1531. }                /* end of update_PctScale */
  1532.  
  1533. /*+-------------------------------------------------------------------------
  1534.     update_Cache_PctScale(x,y,scale_length,totalC,greenC)
  1535. --------------------------------------------------------------------------*/
  1536. void
  1537. update_Cache_PctScale (window, display, gc, DrawAreaXYWH, x, y, scale_length, label, totalC, pixmap, greenC, pixel, pixel2)
  1538.      Window          window;
  1539.      Display        *display;
  1540.      GC              gc;
  1541.      XWindowAttributes DrawAreaXYWH;
  1542.      int             x, y, scale_length;
  1543.      char           *label;
  1544.      long            totalC;
  1545.      Pixmap          pixmap;
  1546.      long            greenC;
  1547.      unsigned long   pixel;
  1548.      unsigned long   pixel2;
  1549. {
  1550.   int             yl = y + (FHEIGHT / 2) - 1;    /* y for lines */
  1551.   int             ys = y + FASCENT;    /* y for strings */
  1552.   int             line_length;
  1553.   int             used_length = 0;
  1554.   int             line_style = LineSolid;
  1555.   int             cap_style = CapButt;
  1556.   int             join_style = JoinMiter;
  1557. #ifdef DEBUG2
  1558.   fprintf (stdout, "In update_Cache_PctScale\n");
  1559. #endif
  1560. /*
  1561.   XClearArea (display, window, x, y - 1, scale_length, FHEIGHT, 0);
  1562. */
  1563.   XSetForeground (display, gc, background);
  1564.   XFillRectangle (display, pixmap, gc, x, y - 1, scale_length, FHEIGHT);
  1565.  
  1566.   if (scale_length < 6)
  1567.     return;
  1568.  
  1569.   XSetLineAttributes (display, gc, FHEIGHT, line_style, cap_style, join_style);
  1570. /*
  1571.  * Protect againts divsion by ZERO....
  1572.  */
  1573.  
  1574.   if (totalC == 0)
  1575.     totalC = 1;
  1576.  
  1577.   if (line_length = (int) (((float) greenC * scale_length) / (float) totalC))
  1578.     {
  1579.       XSetForeground (display, gc, pixel);
  1580. /*
  1581.       XDrawLine (display, window, gc, x, yl, x + line_length, yl);
  1582. */
  1583.       XDrawLine (display, pixmap, gc, x, yl, x + line_length, yl);
  1584.       if (line_length > FWIDTH)
  1585.     {
  1586.       XSetForeground (display, gc, background);
  1587. /*
  1588.       XDrawString (display, window, gc, x, ys, label + 0, 1);
  1589.       XDrawString (display, window, gc, x + 1, ys, label + 0, 1);
  1590. */
  1591.       XDrawString (display, pixmap, gc, x, ys, label + 0, 1);
  1592.       XDrawString (display, pixmap, gc, x + 1, ys, label + 0, 1);
  1593.     }
  1594.       used_length += line_length;
  1595.       x += line_length;
  1596.     }
  1597.  
  1598.   if ((scale_length - used_length) > 0)
  1599.     {
  1600.       XSetForeground (display, gc, pixel2);
  1601. /*
  1602.       XDrawLine (display, window, gc, x, yl, x + scale_length, yl);
  1603. */
  1604.       XDrawLine (display, pixmap, gc, x, yl, x + scale_length, yl);
  1605.     }
  1606.  
  1607. }                /* end of update_PctScale */
  1608.  
  1609. /*+-------------------------------------------------------------------------
  1610.     update_FilesScale(x,y)
  1611.  
  1612. 000000000011111111112222222222333333333344444444445555555555666666
  1613. 012345678901234567890123456789012345678901234567890123456789012345
  1614. cnfg max  curr
  1615. #### #### ####  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  1616.  
  1617.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].window;
  1618.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].display;
  1619.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].gc;
  1620.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].DrawAreaXYWH;
  1621.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].pixmap;
  1622.  
  1623.   int             x = 0;
  1624.   int             y = FHEIGHT;
  1625.  
  1626.  
  1627. --------------------------------------------------------------------------*/
  1628. #define _FILESSCALE_CF    (FWIDTH * 1)
  1629. #define _FILESSCALE_MX    (FWIDTH * 6)
  1630. #define _FILESSCALE_CU    (FWIDTH * 11)
  1631. #define _FILESSCALE_SX    (FWIDTH * 16)
  1632.  
  1633. void
  1634. update_FilesScale (SP)
  1635.      struct NetworkXswStruct *SP;
  1636.  
  1637. {
  1638.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].window;
  1639.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].display;
  1640.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].gc;
  1641.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].DrawAreaXYWH;
  1642.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].pixmap;
  1643.  
  1644.   int             x = 0;
  1645.   int             y = FHEIGHT;
  1646.  
  1647.  
  1648.   unsigned long   pixel;
  1649.   char            numstr[8];
  1650.  
  1651.   int             file_percent;
  1652.   int             inode_percent;
  1653.   int             proc_percent;
  1654.   int             region_percent;
  1655.   int             myclist_percent;
  1656.   int             callout_percent;
  1657.   int             mount_percent;
  1658.  
  1659.  
  1660. #ifdef DEBUG2
  1661.   fprintf (stdout, "In update_FilesScale\n");
  1662. #endif
  1663.   x += current_server -> PctScale_xoffset;
  1664.  
  1665. /*
  1666.   XClearArea (display, window, x, y, FWIDTH * 16, FHEIGHT, 0);
  1667. */
  1668.   XSetForeground (display, gc, background);
  1669.   XFillRectangle (display, pixmap, gc, x, y, FWIDTH * 16, FHEIGHT);
  1670.  
  1671.  
  1672.  
  1673.   if (current_server -> file_count > current_server -> file_max)
  1674.     {
  1675.       current_server -> file_max = current_server -> file_count;
  1676.     }
  1677.  
  1678.   file_percent = (current_server -> file_count * 100) / current_server -> my_v -> v_file;
  1679.  
  1680.   XSetForeground (display, gc, colorStaticNumeric.pixel);
  1681.   sprintf (numstr, "%4ld", current_server -> my_v -> v_file);
  1682. /*
  1683.   XDrawString (display, window, gc,
  1684.            x + _FILESSCALE_CF, y + FASCENT, numstr, 4);
  1685. */
  1686.   XDrawString (display, pixmap, gc,
  1687.            x + _FILESSCALE_CF, y + FASCENT, numstr, 4);
  1688.  
  1689.   if (((current_server -> file_max * 100) / current_server -> my_v -> v_file) > res.nfileAlarmThreshhold)
  1690.     pixel = colorNfileAlarm.pixel;
  1691.   else if (((current_server -> file_max * 100) / current_server -> my_v -> v_file) > res.nfileWarningThreshhold)
  1692.     pixel = colorNfileWarning.pixel;
  1693.   else
  1694.     pixel = colorNfile.pixel;
  1695.  
  1696.   XSetForeground (display, gc, pixel);
  1697.   sprintf (numstr, "%4ld", current_server -> file_max);
  1698. /*
  1699.   XDrawString (display, window, gc,
  1700.            x + _FILESSCALE_MX, y + FASCENT, numstr, 4);
  1701. */
  1702.   XDrawString (display, pixmap, gc,
  1703.            x + _FILESSCALE_MX, y + FASCENT, numstr, 4);
  1704.  
  1705.   if (file_percent > res.nfileAlarmThreshhold)
  1706.     pixel = colorNfileAlarm.pixel;
  1707.   else if (file_percent > res.nfileWarningThreshhold)
  1708.     pixel = colorNfileWarning.pixel;
  1709.   else
  1710.     pixel = colorNfile.pixel;
  1711.  
  1712.   XSetForeground (display, gc, pixel);
  1713.   sprintf (numstr, "%4ld", current_server -> file_count);
  1714. /*
  1715.   XDrawString (display, window, gc,
  1716.            x + _FILESSCALE_CU, y + FASCENT, numstr, 4);
  1717. */
  1718.   XDrawString (display, pixmap, gc,
  1719.            x + _FILESSCALE_CU, y + FASCENT, numstr, 4);
  1720.  
  1721.   update_Single_PctScale (
  1722.                window, display, gc, DrawAreaXYWH, pixmap,
  1723.                x + _FILESSCALE_SX, y,
  1724.                SP ->
  1725.        SEPERATE_WINDOWS_LIST[BUTTON_other].width - (x + _FILESSCALE_SX),
  1726.                "f", 100, file_percent, pixel);
  1727.  
  1728. /* Begin inode */
  1729. /*
  1730.   XClearArea (display, window, x, y + FHEIGHT, FWIDTH * 16, FHEIGHT, 0);
  1731. */
  1732.   XSetForeground (display, gc, background);
  1733.   XFillRectangle (display, pixmap, gc, x, y + FHEIGHT, FWIDTH * 16, FHEIGHT);
  1734.  
  1735.  
  1736.   if (current_server -> inode_count > current_server -> inode_max)
  1737.     {
  1738.       current_server -> inode_max = current_server -> inode_count;
  1739.     }
  1740.  
  1741.   inode_percent = (current_server -> inode_count * 100) / current_server -> my_v -> v_inode;
  1742.  
  1743.   XSetForeground (display, gc, colorStaticNumeric.pixel);
  1744.   sprintf (numstr, "%4ld", current_server -> my_v -> v_inode);
  1745. /*
  1746.   XDrawString (display, window, gc,
  1747.            x + _FILESSCALE_CF, y + FASCENT + FHEIGHT, numstr, 4);
  1748. */
  1749.   XDrawString (display, pixmap, gc,
  1750.            x + _FILESSCALE_CF, y + FASCENT + FHEIGHT, numstr, 4);
  1751.  
  1752.   if (((current_server -> inode_max * 100) / current_server -> my_v -> v_inode) > res.ninodeAlarmThreshhold)
  1753.     pixel = colorNinodeAlarm.pixel;
  1754.   else if (((current_server -> inode_max * 100) / current_server -> my_v -> v_inode) > res.ninodeWarningThreshhold)
  1755.     pixel = colorNinodeWarning.pixel;
  1756.   else
  1757.     pixel = colorNinode.pixel;
  1758.  
  1759.  
  1760.   XSetForeground (display, gc, pixel);
  1761.   sprintf (numstr, "%4ld", current_server -> inode_max);
  1762. /*
  1763.   XDrawString (display, window, gc,
  1764.            x + _FILESSCALE_MX, y + FASCENT + FHEIGHT, numstr, 4);
  1765. */
  1766.   XDrawString (display, pixmap, gc,
  1767.            x + _FILESSCALE_MX, y + FASCENT + FHEIGHT, numstr, 4);
  1768.  
  1769.   if (inode_percent > res.ninodeAlarmThreshhold)
  1770.     pixel = colorNinodeAlarm.pixel;
  1771.   else if (inode_percent > res.ninodeWarningThreshhold)
  1772.     pixel = colorNinodeWarning.pixel;
  1773.   else
  1774.     pixel = colorNinode.pixel;
  1775.  
  1776.   XSetForeground (display, gc, pixel);
  1777.   sprintf (numstr, "%4ld", current_server -> inode_count);
  1778. /*
  1779.   XDrawString (display, window, gc,
  1780.            x + _FILESSCALE_CU, y + FASCENT + FHEIGHT, numstr, 4);
  1781. */
  1782.   XDrawString (display, pixmap, gc,
  1783.            x + _FILESSCALE_CU, y + FASCENT + FHEIGHT, numstr, 4);
  1784.  
  1785.   update_Single_PctScale (
  1786.                window, display, gc, DrawAreaXYWH, pixmap,
  1787.                x + _FILESSCALE_SX,
  1788.                y + FHEIGHT,
  1789.      SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - (x + _FILESSCALE_SX),
  1790.                "i", 100, inode_percent, pixel);
  1791.  
  1792. /* Begin proc */
  1793. /*
  1794.   XClearArea (display, window, x, y + (FHEIGHT * 2), FWIDTH * 16, FHEIGHT, 0);
  1795. */
  1796.   XSetForeground (display, gc, background);
  1797.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 2), FWIDTH * 16, FHEIGHT);
  1798.  
  1799.  
  1800.  
  1801.   if (current_server -> proc_count > current_server -> proc_max)
  1802.     {
  1803.       current_server -> proc_max = current_server -> proc_count;
  1804.     }
  1805.  
  1806.   proc_percent = (current_server -> proc_count * 100) / current_server -> my_v -> v_proc;
  1807.  
  1808.   XSetForeground (display, gc, colorStaticNumeric.pixel);
  1809.   sprintf (numstr, "%4ld", current_server -> my_v -> v_proc);
  1810. /*
  1811.   XDrawString (display, window, gc,
  1812.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 2), numstr, 4);
  1813. */
  1814.   XDrawString (display, pixmap, gc,
  1815.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 2), numstr, 4);
  1816.  
  1817.   if (((current_server -> proc_max * 100) / current_server -> my_v -> v_proc) > res.nprocAlarmThreshhold)
  1818.     pixel = colorNprocAlarm.pixel;
  1819.   else if (((current_server -> proc_max * 100) / current_server -> my_v -> v_proc) > res.nprocWarningThreshhold)
  1820.     pixel = colorNprocWarning.pixel;
  1821.   else
  1822.     pixel = colorNproc.pixel;
  1823.  
  1824.   XSetForeground (display, gc, pixel);
  1825.  
  1826.   sprintf (numstr, "%4ld", current_server -> proc_max);
  1827. /*
  1828.   XDrawString (display, window, gc,
  1829.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 2), numstr, 4);
  1830. */
  1831.   XDrawString (display, pixmap, gc,
  1832.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 2), numstr, 4);
  1833.  
  1834.   if (proc_percent > res.nprocAlarmThreshhold)
  1835.     pixel = colorNprocAlarm.pixel;
  1836.   else if (proc_percent > res.nprocWarningThreshhold)
  1837.     pixel = colorNprocWarning.pixel;
  1838.   else
  1839.     pixel = colorNproc.pixel;
  1840.  
  1841.   XSetForeground (display, gc, pixel);
  1842.   sprintf (numstr, "%4ld", current_server -> proc_count);
  1843. /*
  1844.   XDrawString (display, window, gc,
  1845.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 2), numstr, 4);
  1846. */
  1847.   XDrawString (display, pixmap, gc,
  1848.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 2), numstr, 4);
  1849.  
  1850.   update_Single_PctScale (
  1851.                window, display, gc, DrawAreaXYWH, pixmap,
  1852.                x + _FILESSCALE_SX,
  1853.                y + (FHEIGHT * 2),
  1854.      SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - (x + _FILESSCALE_SX),
  1855.                "p", 100,
  1856.                proc_percent, pixel);
  1857.  
  1858. /* Begin region */
  1859. /*
  1860.   XClearArea (display, window, x, y + (FHEIGHT * 3), FWIDTH * 16, FHEIGHT, 0);
  1861. */
  1862.   XSetForeground (display, gc, background);
  1863.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 3), FWIDTH * 16, FHEIGHT
  1864.     );
  1865.  
  1866.   if (current_server -> region_count > current_server -> region_max)
  1867.     {
  1868.       current_server -> region_max = current_server -> region_count;
  1869.     }
  1870.  
  1871.   region_percent = (current_server -> region_count * 100) / current_server -> my_v -> v_region;
  1872.  
  1873.  
  1874.   XSetForeground (display, gc, colorStaticNumeric.pixel);
  1875.   sprintf (numstr, "%4ld", current_server -> my_v -> v_region);
  1876. /*
  1877.   XDrawString (display, window, gc,
  1878.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 3), numstr, 4);
  1879. */
  1880.   XDrawString (display, pixmap, gc,
  1881.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 3), numstr, 4);
  1882.  
  1883.   XSetForeground (display, gc, colorNumeric.pixel);
  1884.  
  1885.   if (((current_server -> region_max * 100) / current_server -> my_v -> v_region) > res.nregionAlarmThreshhold)
  1886.     pixel = colorNregionAlarm.pixel;
  1887.   else if (((current_server -> region_max * 100) / current_server -> my_v -> v_region) > res.nregionWarningThreshhold)
  1888.     pixel = colorNregionWarning.pixel;
  1889.   else
  1890.     pixel = colorNregion.pixel;
  1891.  
  1892.   XSetForeground (display, gc, pixel);
  1893.  
  1894.   sprintf (numstr, "%4ld", current_server -> region_max);
  1895. /*
  1896.   XDrawString (display, window, gc,
  1897.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 3), numstr, 4);
  1898. */
  1899.   XDrawString (display, pixmap, gc,
  1900.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 3), numstr, 4);
  1901.  
  1902.   if (region_percent > res.nregionAlarmThreshhold)
  1903.     pixel = colorNregionAlarm.pixel;
  1904.   else if (region_percent > res.nregionWarningThreshhold)
  1905.     pixel = colorNregionWarning.pixel;
  1906.   else
  1907.     pixel = colorNregion.pixel;
  1908.  
  1909.   XSetForeground (display, gc, pixel);
  1910.   sprintf (numstr, "%4ld", current_server -> region_count);
  1911. /*
  1912.   XDrawString (display, window, gc,
  1913.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 3), numstr, 4);
  1914. */
  1915.   XDrawString (display, pixmap, gc,
  1916.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 3), numstr, 4);
  1917.  
  1918.   update_Single_PctScale (
  1919.                window, display, gc, DrawAreaXYWH, pixmap,
  1920.                x + _FILESSCALE_SX, y + (FHEIGHT * 3),
  1921.                SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - (x + _FILESSCALE_SX), "r", 100,
  1922.                region_percent, pixel);
  1923.  
  1924. /* Begin clist */
  1925. /*
  1926.   XClearArea (display, window, x, y + (FHEIGHT * 4), FWIDTH * 16, FHEIGHT, 0);
  1927. */
  1928.   XSetForeground (display, gc, background);
  1929.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 4), FWIDTH * 16, FHEIGHT
  1930.     );
  1931.  
  1932.  
  1933.   if (current_server -> myclist > current_server -> myclist_max)
  1934.     {
  1935.       current_server -> myclist_max = current_server -> myclist;
  1936.     }
  1937.  
  1938.   myclist_percent = (current_server -> myclist * 100) / current_server -> my_v -> v_clist;
  1939.  
  1940.   XSetForeground (display, gc, colorStaticNumeric.pixel);
  1941.   sprintf (numstr, "%4ld", current_server -> my_v -> v_clist);
  1942. /*
  1943.   XDrawString (display, window, gc,
  1944.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  1945. */
  1946.   XDrawString (display, pixmap, gc,
  1947.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  1948.  
  1949.  
  1950.   XSetForeground (display, gc, colorNumeric.pixel);
  1951.  
  1952.   if (((current_server -> myclist_max * 100) / current_server -> my_v -> v_clist) > res.ncblocksAlarmThreshhold)
  1953.     pixel = colorNcblocksAlarm.pixel;
  1954.   else if (((current_server -> myclist_max * 100) / current_server -> my_v -> v_clist) > res.ncblocksWarningThreshhold)
  1955.     pixel = colorNcblocksWarning.pixel;
  1956.   else
  1957.     pixel = colorNcblocks.pixel;
  1958.  
  1959.   XSetForeground (display, gc, pixel);
  1960.  
  1961.   sprintf (numstr, "%4ld", current_server -> myclist_max);
  1962. /*
  1963.   XDrawString (display, window, gc,
  1964.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  1965. */
  1966.   XDrawString (display, pixmap, gc,
  1967.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  1968.  
  1969.   if (myclist_percent > res.ncblocksAlarmThreshhold)
  1970.     pixel = colorNcblocksAlarm.pixel;
  1971.   else if (myclist_percent > res.ncblocksWarningThreshhold)
  1972.     pixel = colorNcblocksWarning.pixel;
  1973.   else
  1974.     pixel = colorNcblocks.pixel;
  1975.  
  1976.   XSetForeground (display, gc, pixel);
  1977.   sprintf (numstr, "%4ld", current_server -> myclist);
  1978. /*
  1979.   XDrawString (display, window, gc,
  1980.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  1981. */
  1982.   XDrawString (display, pixmap, gc,
  1983.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  1984.  
  1985.   update_Single_PctScale (
  1986.                window, display, gc, DrawAreaXYWH, pixmap,
  1987.                x + _FILESSCALE_SX,
  1988.                y + (FHEIGHT * 4),
  1989.      SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - (x + _FILESSCALE_SX),
  1990.                "c", 100, myclist_percent, pixel);
  1991.  
  1992. /* Begin */
  1993. /*
  1994.   XClearArea (display, window, x, y + (FHEIGHT * 4), FWIDTH * 16, FHEIGHT, 0);
  1995. */
  1996.   XSetForeground (display, gc, background);
  1997.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 5), FWIDTH * 16, FHEIGHT
  1998.     );
  1999.  
  2000. #ifndef XSW32v5   
  2001.   if (current_server -> callout_count > current_server -> callout_max)
  2002.     {
  2003.       current_server -> callout_max = current_server -> callout_count;
  2004.     }
  2005.  
  2006.   callout_percent = (current_server -> callout_count * 100) / current_server -> my_v -> v_call;
  2007.   XSetForeground (display, gc, colorStaticNumeric.pixel);
  2008.   sprintf (numstr, "%4ld", current_server -> my_v -> v_call);
  2009. /*
  2010.   XDrawString (display, window, gc,
  2011.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  2012. */
  2013.   XDrawString (display, pixmap, gc,
  2014.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 5), numstr, 4);
  2015.  
  2016.  
  2017.   XSetForeground (display, gc, colorNumeric.pixel);
  2018.  
  2019.   if (((current_server -> callout_max * 100) / current_server -> my_v -> v_call) > res.ncblocksAlarmThreshhold)
  2020.     pixel = colorNcblocksAlarm.pixel;
  2021.   else if (((current_server -> callout_max * 100) / current_server -> my_v -> v_call) > res.ncblocksWarningThreshhold)
  2022.     pixel = colorNcblocksWarning.pixel;
  2023.   else
  2024.     pixel = colorNcblocks.pixel;
  2025.  
  2026.   XSetForeground (display, gc, pixel);
  2027.  
  2028.   sprintf (numstr, "%4ld", current_server -> callout_max);
  2029. /*
  2030.   XDrawString (display, window, gc,
  2031.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  2032. */
  2033.   XDrawString (display, pixmap, gc,
  2034.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 5), numstr, 4);
  2035.  
  2036.   if (callout_percent > res.ncblocksAlarmThreshhold)
  2037.     pixel = colorNcblocksAlarm.pixel;
  2038.   else if (callout_percent > res.ncblocksWarningThreshhold)
  2039.     pixel = colorNcblocksWarning.pixel;
  2040.   else
  2041.     pixel = colorNcblocks.pixel;
  2042.  
  2043.   XSetForeground (display, gc, pixel);
  2044.   sprintf (numstr, "%4ld", current_server -> callout_count);
  2045. /*
  2046.   XDrawString (display, window, gc,
  2047.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  2048. */
  2049.   XDrawString (display, pixmap, gc,
  2050.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 5), numstr, 4);
  2051.  
  2052. #endif
  2053.   update_Single_PctScale (
  2054.                window, display, gc, DrawAreaXYWH, pixmap,
  2055.                x + _FILESSCALE_SX,
  2056.                y + (FHEIGHT * 5),
  2057.      SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - (x + _FILESSCALE_SX),
  2058.                "c", 100, callout_percent, pixel);
  2059.  
  2060.  
  2061. /* Begin */
  2062. /*
  2063.   XClearArea (display, window, x, y + (FHEIGHT * 6), FWIDTH * 16, FHEIGHT, 0);
  2064. */
  2065.   XSetForeground (display, gc, background);
  2066.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 6), FWIDTH * 16, FHEIGHT
  2067.     );
  2068.  
  2069.  
  2070.   if (current_server -> mount_count > current_server -> mount_max)
  2071.     {
  2072.       current_server -> mount_max = current_server -> mount_count;
  2073.     }
  2074.  
  2075.   mount_percent = (current_server -> mount_count * 100) / current_server -> my_v -> v_mount;
  2076.  
  2077.   XSetForeground (display, gc, colorStaticNumeric.pixel);
  2078.   sprintf (numstr, "%4ld", current_server -> my_v -> v_mount);
  2079. /*
  2080.   XDrawString (display, window, gc,
  2081.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 4), numstr, 4);
  2082. */
  2083.   XDrawString (display, pixmap, gc,
  2084.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 6), numstr, 4);
  2085.  
  2086.  
  2087.   XSetForeground (display, gc, colorNumeric.pixel);
  2088.  
  2089.   if (((current_server -> mount_max * 100) / current_server -> my_v -> v_mount) > res.ncblocksAlarmThreshhold)
  2090.     pixel = colorNcblocksAlarm.pixel;
  2091.   else if (((current_server -> mount_max * 100) / current_server -> my_v -> v_mount) > res.ncblocksWarningThreshhold)
  2092.     pixel = colorNcblocksWarning.pixel;
  2093.   else
  2094.     pixel = colorNcblocks.pixel;
  2095.  
  2096.   XSetForeground (display, gc, pixel);
  2097.  
  2098.   sprintf (numstr, "%4ld", current_server -> mount_max);
  2099. /*
  2100.   XDrawString (display, window, gc,
  2101.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 6), numstr, 4);
  2102. */
  2103.   XDrawString (display, pixmap, gc,
  2104.            x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 6), numstr, 4);
  2105.  
  2106.   if (mount_percent > res.ncblocksAlarmThreshhold)
  2107.     pixel = colorNcblocksAlarm.pixel;
  2108.   else if (mount_percent > res.ncblocksWarningThreshhold)
  2109.     pixel = colorNcblocksWarning.pixel;
  2110.   else
  2111.     pixel = colorNcblocks.pixel;
  2112.  
  2113.   XSetForeground (display, gc, pixel);
  2114.   sprintf (numstr, "%4ld", current_server -> mount_count);
  2115. /*
  2116.   XDrawString (display, window, gc,
  2117.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 6), numstr, 4);
  2118. */
  2119.   XDrawString (display, pixmap, gc,
  2120.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 6), numstr, 4);
  2121.  
  2122.   update_Single_PctScale (
  2123.                window, display, gc, DrawAreaXYWH, pixmap,
  2124.                x + _FILESSCALE_SX,
  2125.                y + (FHEIGHT * 6),
  2126.      SP -> SEPERATE_WINDOWS_LIST[BUTTON_other].width - (x + _FILESSCALE_SX),
  2127.                "c", 100, mount_percent, pixel);
  2128.  
  2129.  
  2130.  
  2131. }                /* end of update_FilesScale */
  2132.  
  2133. /*+-------------------------------------------------------------------------
  2134.     update_CacheScale(x,y)
  2135.  
  2136. 000000000011111111112222222222333333333344444444445555555555666666
  2137. 012345678901234567890123456789012345678901234567890123456789012345
  2138.      avg  curr
  2139. #### #### ####  xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  2140. --------------------------------------------------------------------------*/
  2141. void
  2142. update_CacheScale (SP)
  2143.      struct NetworkXswStruct *SP;
  2144.  
  2145. {
  2146.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].window;
  2147.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].display;
  2148.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].gc;
  2149.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].DrawAreaXYWH;
  2150.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_cache].pixmap;
  2151.  
  2152.   int             x = 0;
  2153.   int             y = FHEIGHT;
  2154.  
  2155.  
  2156.   unsigned long   pixel;
  2157.   char            numstr[8];
  2158.   char           *cptr;
  2159.  
  2160.   long            current_lwrite, current_bwrite;
  2161.   int             percent_cache_write_hit;
  2162.   long            current_lread, current_bread;
  2163.   int             percent_cache_read_hit;
  2164.  
  2165.  
  2166. #ifdef DEBUG2
  2167.   fprintf (stdout, "In update_CacheScale\n");
  2168. #endif
  2169.   x += current_server -> PctScale_xoffset;
  2170.  
  2171.  
  2172. /* Begin Cache Write */
  2173. /*
  2174.   XClearArea (display, window, x, y, FWIDTH * 16, FHEIGHT, 0);
  2175. */
  2176.   XSetForeground (display, gc, background);
  2177.   XFillRectangle (display, pixmap, gc, x, y, FWIDTH * 16, FHEIGHT);
  2178.  
  2179.   current_lwrite = sysidelta (lwrite);
  2180.   current_bwrite = sysidelta (bwrite);
  2181.  
  2182. /* FACT : bwrite <= lwrite */
  2183.  
  2184.   if (current_lwrite != 0)
  2185.     {
  2186.       if (current_bwrite == current_lwrite)
  2187.     percent_cache_write_hit = 0;
  2188.       else if (current_bwrite > current_lwrite)
  2189.     percent_cache_write_hit = 100;
  2190.       else
  2191.     percent_cache_write_hit = (int) (
  2192.               (float) ((float) (current_lwrite - current_bwrite)
  2193.                    / current_lwrite) * 100);
  2194.  
  2195.       current_server -> lwrite_cummulative = current_server -> my_sysinfo -> lwrite - current_server -> initial_lwrite;
  2196.       current_server -> bwrite_cummulative = current_server -> my_sysinfo -> bwrite - current_server -> initial_bwrite;
  2197.  
  2198.       current_server -> avg_percent_write = (int) (
  2199.                             (float) ((float) (current_server -> lwrite_cummulative - current_server -> bwrite_cummulative)
  2200.                  / current_server -> lwrite_cummulative) * 100);
  2201.  
  2202.       if (current_server -> avg_percent_write < res.writeCacheAlarmThreshhold)
  2203.     pixel = colorNumericAlarm.pixel;
  2204.       else if (current_server -> avg_percent_write < res.writeCacheWarningThreshhold)
  2205.     pixel = colorNumericWarning.pixel;
  2206.       else
  2207.     pixel = colorNumeric.pixel;
  2208.  
  2209.       sprintf (numstr, "%4ld", current_server -> avg_percent_write);
  2210.       XSetForeground (display, gc, pixel);
  2211. /*
  2212.       XDrawString (display, window, gc,
  2213.            x + _FILESSCALE_MX, y + FASCENT, numstr, 4);
  2214. */
  2215.       XDrawString (display, pixmap, gc,
  2216.            x + _FILESSCALE_MX, y + FASCENT, numstr, 4);
  2217.  
  2218.       if (percent_cache_write_hit < res.writeCacheAlarmThreshhold)
  2219.     pixel = colorNumericAlarm.pixel;
  2220.       else if (percent_cache_write_hit < res.writeCacheWarningThreshhold)
  2221.     pixel = colorNumericWarning.pixel;
  2222.       else
  2223.     pixel = colorNumeric.pixel;
  2224.  
  2225.       XSetForeground (display, gc, pixel);
  2226.       sprintf (numstr, "%4ld", percent_cache_write_hit);
  2227. /*
  2228.       XDrawString (display, window, gc,
  2229.            x + _FILESSCALE_CU, y + FASCENT, numstr, 4);
  2230. */
  2231.       XDrawString (display, pixmap, gc,
  2232.            x + _FILESSCALE_CU, y + FASCENT, numstr, 4);
  2233.  
  2234.       if (percent_cache_write_hit < res.writeCacheAlarmThreshhold)
  2235.     pixel = colorCacheWriteMissAlarm.pixel;
  2236.       else if (percent_cache_write_hit < res.writeCacheWarningThreshhold)
  2237.     pixel = colorCacheWriteMissWarning.pixel;
  2238.       else
  2239.     pixel = colorCacheWriteMiss.pixel;
  2240.  
  2241.       update_Cache_PctScale (window, display, gc, DrawAreaXYWH,
  2242.                  x + _FILESSCALE_SX, y,
  2243.                  current_server -> SEPERATE_WINDOWS_LIST[BUTTON_cache].width - (x + _FILESSCALE_SX),
  2244.                  "H", 100, pixmap,
  2245.                  percent_cache_write_hit,
  2246.                  colorCacheWriteHit.pixel, pixel);
  2247.     }
  2248.   else
  2249.     {
  2250.       cptr = "     ";
  2251. /*
  2252.       XDrawString (display, window, gc,
  2253.            x + _FILESSCALE_CF, y + FASCENT,
  2254.            cptr, strlen (cptr));
  2255. */
  2256.       XDrawString (display, pixmap, gc,
  2257.            x + _FILESSCALE_CF, y + FASCENT,
  2258.            cptr, strlen (cptr));
  2259.  
  2260.       if (current_server -> avg_percent_write < res.writeCacheAlarmThreshhold)
  2261.     pixel = colorNumericAlarm.pixel;
  2262.       else if (current_server -> avg_percent_write < res.writeCacheWarningThreshhold)
  2263.     pixel = colorNumericWarning.pixel;
  2264.       else
  2265.     pixel = colorNumeric.pixel;
  2266.  
  2267.       sprintf (numstr, "%4ld", current_server -> avg_percent_write);
  2268.       XSetForeground (display, gc, pixel);
  2269. /*
  2270.       XDrawString (display, window, gc,
  2271.            x + _FILESSCALE_MX, y + FASCENT, numstr, 4);
  2272. */
  2273.       XDrawString (display, pixmap, gc,
  2274.            x + _FILESSCALE_MX, y + FASCENT, numstr, 4);
  2275.  
  2276.       XSetForeground (display, gc, colorNumeric.pixel);
  2277.       cptr = " N/A";
  2278. /*
  2279.       XDrawString (display, window, gc, x + _FILESSCALE_CU,
  2280.            y + FASCENT, cptr, strlen (cptr));
  2281. */
  2282.       XDrawString (display, pixmap, gc, x + _FILESSCALE_CU,
  2283.            y + FASCENT, cptr, strlen (cptr));
  2284. /*
  2285.       XClearArea (display, window,
  2286.           x + _FILESSCALE_SX, y - 1,
  2287.           DrawAreaXYWH.width, FHEIGHT, 0);
  2288. */
  2289.       XSetForeground (display, gc, background);
  2290.       XFillRectangle (display, pixmap, gc, x + _FILESSCALE_SX, y - 1,
  2291.       current_server -> SEPERATE_WINDOWS_LIST[BUTTON_cache].width, FHEIGHT);
  2292.     }
  2293.  
  2294.  
  2295. /* Begin Cache Read */
  2296. /*
  2297.   XClearArea (display, window, x, y + (FHEIGHT * 1), FWIDTH * 16, FHEIGHT, 0);
  2298. */
  2299.   XSetForeground (display, gc, background);
  2300.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 1),
  2301.           FWIDTH * 16, FHEIGHT);
  2302.  
  2303.   current_lread = sysidelta (lread);
  2304.   current_bread = sysidelta (bread);
  2305.  
  2306.   if (current_lread != 0)
  2307.     {
  2308.       cptr = "                ";
  2309. /*
  2310.       XDrawString (display, window, gc,
  2311.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 1),
  2312.            cptr, strlen (cptr));
  2313. */
  2314.       XDrawString (display, pixmap, gc,
  2315.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 1),
  2316.            cptr, strlen (cptr));
  2317.  
  2318.       if (current_bread == current_lread)
  2319.     percent_cache_read_hit = 0;
  2320.       else if (current_bread > current_lread)
  2321.     percent_cache_read_hit = 100;
  2322.       else
  2323.     percent_cache_read_hit = (int)
  2324.       ((float) ((float) (current_lread - current_bread) /
  2325.             current_lread) * 100);
  2326.  
  2327.       current_server -> lread_cummulative = current_server -> my_sysinfo -> lread - current_server -> initial_lread;
  2328.       current_server -> bread_cummulative = current_server -> my_sysinfo -> bread - current_server -> initial_bread;
  2329.  
  2330.       current_server -> avg_percent_read = (int)
  2331.     ((float) ((float) (current_server -> lread_cummulative - current_server -> bread_cummulative) / current_server -> lread_cummulative) * 100);
  2332.  
  2333.       if (current_server -> avg_percent_read < res.readCacheAlarmThreshhold)
  2334.     pixel = colorNumericAlarm.pixel;
  2335.       else if (current_server -> avg_percent_read < res.readCacheWarningThreshhold)
  2336.     pixel = colorNumericWarning.pixel;
  2337.       else
  2338.     pixel = colorNumeric.pixel;
  2339.  
  2340.       sprintf (numstr, "%4ld", current_server -> avg_percent_read);
  2341.       XSetForeground (display, gc, pixel);
  2342. /*
  2343.       XDrawString (display, window, gc,
  2344.         x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 1), numstr, 4);
  2345. */
  2346.       XDrawString (display, pixmap, gc,
  2347.         x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 1), numstr, 4);
  2348.  
  2349.       if (percent_cache_read_hit < res.readCacheAlarmThreshhold)
  2350.     pixel = colorNumericAlarm.pixel;
  2351.       else if (percent_cache_read_hit < res.readCacheWarningThreshhold)
  2352.     pixel = colorNumericWarning.pixel;
  2353.       else
  2354.     pixel = colorNumeric.pixel;
  2355.  
  2356.       XSetForeground (display, gc, pixel);
  2357.       sprintf (numstr, "%4ld%", percent_cache_read_hit);
  2358. /*
  2359.       XDrawString (display, window, gc,
  2360.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 1),
  2361.            numstr, 4);
  2362. */
  2363.       XDrawString (display, pixmap, gc,
  2364.            x + _FILESSCALE_CU, y + FASCENT + (FHEIGHT * 1),
  2365.            numstr, 4);
  2366.  
  2367.       if (percent_cache_read_hit < res.readCacheAlarmThreshhold)
  2368.     pixel = colorCacheReadMissAlarm.pixel;
  2369.       else if (percent_cache_read_hit < res.readCacheWarningThreshhold)
  2370.     pixel = colorCacheReadMissWarning.pixel;
  2371.       else
  2372.     pixel = colorCacheReadMiss.pixel;
  2373.  
  2374.       update_Cache_PctScale (
  2375.                   window, display, gc, DrawAreaXYWH,
  2376.                   x + _FILESSCALE_SX, y + (FHEIGHT * 1),
  2377.                   current_server -> SEPERATE_WINDOWS_LIST[BUTTON_cache].width - (x + _FILESSCALE_SX),
  2378.                   "H", 100, pixmap,
  2379.                   percent_cache_read_hit,
  2380.                   colorCacheReadHit.pixel, pixel);
  2381.     }
  2382.   else
  2383.     {
  2384.       cptr = "     ";
  2385. /*
  2386.       XDrawString (display, window, gc,
  2387.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 1),
  2388.            cptr, strlen (cptr));
  2389. */
  2390.       XDrawString (display, pixmap, gc,
  2391.            x + _FILESSCALE_CF, y + FASCENT + (FHEIGHT * 1),
  2392.            cptr, strlen (cptr));
  2393.  
  2394.       if (current_server -> avg_percent_read < res.readCacheAlarmThreshhold)
  2395.     pixel = colorNumericAlarm.pixel;
  2396.       else if (current_server -> avg_percent_read < res.readCacheWarningThreshhold)
  2397.     pixel = colorNumericWarning.pixel;
  2398.       else
  2399.     pixel = colorNumeric.pixel;
  2400.  
  2401.       sprintf (numstr, "%4ld", current_server -> avg_percent_read);
  2402.       XSetForeground (display, gc, pixel);
  2403. /*
  2404.       XDrawString (display, window, gc,
  2405.         x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 1), numstr, 4);
  2406. */
  2407.       XDrawString (display, pixmap, gc,
  2408.         x + _FILESSCALE_MX, y + FASCENT + (FHEIGHT * 1), numstr, 4);
  2409.  
  2410.       XSetForeground (display, gc, colorNumeric.pixel);
  2411.       cptr = " N/A";
  2412. /*
  2413.       XDrawString (display, window, gc, x + _FILESSCALE_CU,
  2414.            y + FASCENT + (FHEIGHT * 1), cptr, strlen (cptr));
  2415. */
  2416.       XDrawString (display, pixmap, gc, x + _FILESSCALE_CU,
  2417.            y + FASCENT + (FHEIGHT * 1), cptr, strlen (cptr));
  2418. /*
  2419.       XClearArea (display, window,
  2420.           x + _FILESSCALE_SX, y + (FHEIGHT * 1) - 1,
  2421.           DrawAreaXYWH.width, FHEIGHT, 0);
  2422. */
  2423.       XSetForeground (display, gc, background);
  2424.       XFillRectangle (display, pixmap, gc, x + _FILESSCALE_SX, y + (FHEIGHT * 1) - 1,
  2425.       current_server -> SEPERATE_WINDOWS_LIST[BUTTON_cache].width, FHEIGHT);
  2426.     }
  2427.  
  2428.  
  2429. }                /* end of update_CacheScale */
  2430.  
  2431. #define _MEMCUR   (FWIDTH * 1)
  2432. #define _MEMSCALE (FWIDTH * 9)
  2433. /*+-------------------------------------------------------------------------
  2434.     update_MemScale(x,y,per_state)
  2435.  
  2436. 000000000011111111112222222222333333333344444444445555555555666666
  2437. 012345678901234567890123456789012345678901234567890123456789012345
  2438. tot usr ker brk
  2439. ### ### ### ### xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
  2440. --------------------------------------------------------------------------*/
  2441. void
  2442. update_MemScale (SP)
  2443.      struct NetworkXswStruct *SP;
  2444.  
  2445. {
  2446.   Window          window = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].window;
  2447.   Display        *display = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].display;
  2448.   GC              gc = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].gc;
  2449.   XWindowAttributes DrawAreaXYWH = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].DrawAreaXYWH;
  2450.   Pixmap          pixmap = SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].pixmap;
  2451.  
  2452.   int             x = 0;
  2453.   int             y = FHEIGHT;
  2454.  
  2455.   unsigned long   Mempixel;
  2456.   unsigned long   Swappixel;
  2457.   unsigned long   AvailSwappixel;
  2458.  
  2459.   char            numstr[9];
  2460.  
  2461.   int             avg_percent_memory_used;
  2462.   int             avg_percent_swap_used;
  2463.   int             avg_percent_avail_swap_used;
  2464.  
  2465.   int             percent_memory_used = 100 - (int) ((*current_server -> my_freemem * 100) / *current_server -> my_maxmem);
  2466.   int             percent_swap_used = 100 - (int)
  2467.   ((current_server -> my_minfo -> freeswap * NBPSCTR / 1024) * 100) / current_server -> my_nswap;
  2468.   int             percent_avail_swap_used =
  2469.   100 - (int) (((*current_server -> my_availsmem * NBPP / 1024) * 100) /
  2470.            (current_server -> my_nswap + (*current_server -> my_maxmem * NBPP / 1024)));
  2471.  
  2472. /* In case of long "roll over", re-initialize */
  2473.  
  2474.   if (((current_server -> cummulative_swap_used * 100) < 0) ||
  2475.       ((current_server -> cummulative_avail_swap * 100) < 0) ||
  2476.       ((current_server -> cummulative_memory_used * 100) < 0))
  2477.     {
  2478.       current_server -> cummulative_memory_used = *current_server -> my_freemem;
  2479.       current_server -> cummulative_swap_used = current_server -> my_minfo -> freeswap * NBPSCTR / 1024;
  2480.       current_server -> cummulative_avail_swap = *current_server -> my_availsmem;
  2481.       current_server -> memory_sample_count = 1;
  2482.  
  2483.     }
  2484.  
  2485.   avg_percent_memory_used = 100 - (int)
  2486.     ((current_server -> cummulative_memory_used * 100) / (current_server -> memory_sample_count * *current_server -> my_maxmem));
  2487.  
  2488.   avg_percent_swap_used = 100 - (int)
  2489.     (current_server -> cummulative_swap_used * 100) / (long) (current_server -> my_nswap * current_server -> memory_sample_count);
  2490.  
  2491.   avg_percent_avail_swap_used =
  2492.     100 - (int) ((current_server -> cummulative_avail_swap * 100) /
  2493.          ((current_server -> my_nswap + (*current_server -> my_maxmem * NBPP / 1024)) * current_server -> memory_sample_count));
  2494.  
  2495.   if (percent_memory_used > res.memUsedAlarmThreshhold)
  2496.     Mempixel = colorMemUsedAlarm.pixel;
  2497.   else if (percent_memory_used > res.memUsedWarningThreshhold)
  2498.     Mempixel = colorMemUsedWarning.pixel;
  2499.   else
  2500.     Mempixel = colorMemUsed.pixel;
  2501.  
  2502.   x += (FWIDTH * 19);
  2503.  
  2504. /*
  2505.   XClearArea (display, window, x, y, FWIDTH * 10, FHEIGHT, 0);
  2506. */
  2507.   XSetForeground (display, gc, background);
  2508.   XFillRectangle (display, pixmap, gc, x, y, FWIDTH * 10, FHEIGHT);
  2509.  
  2510.  
  2511.   XSetForeground (display, gc, Mempixel);
  2512.   sprintf (numstr, "%3d  %3d", avg_percent_memory_used,
  2513.        percent_memory_used);
  2514. /*
  2515.   XDrawString (display, window, gc,
  2516.            x + _MEMCUR, y + FASCENT, numstr, 8);
  2517. */
  2518.   XDrawString (display, pixmap, gc,
  2519.            x + _MEMCUR, y + FASCENT, numstr, 8);
  2520. /*
  2521.   XClearArea (display, window, x, y + FHEIGHT, FWIDTH * 10, FHEIGHT, 0);
  2522. */
  2523.  
  2524.   XSetForeground (display, gc, background);
  2525.   XFillRectangle (display, pixmap, gc, x, y + FHEIGHT, FWIDTH * 10, FHEIGHT);
  2526.  
  2527.   if (percent_swap_used > res.swapUsedAlarmThreshhold)
  2528.     Swappixel = colorSwapUsedAlarm.pixel;
  2529.   else if (percent_swap_used > res.swapUsedWarningThreshhold)
  2530.     Swappixel = colorSwapUsedWarning.pixel;
  2531.   else
  2532.     Swappixel = colorSwapUsed.pixel;
  2533.  
  2534.   XSetForeground (display, gc, Swappixel);
  2535.   sprintf (numstr, "%3d  %3d", avg_percent_swap_used, percent_swap_used);
  2536. /*
  2537.   XDrawString (display, window, gc,
  2538.            x + _MEMCUR, y + FASCENT + FHEIGHT, numstr, 8);
  2539. */
  2540.   XDrawString (display, pixmap, gc,
  2541.            x + _MEMCUR, y + FASCENT + FHEIGHT, numstr, 8);
  2542.  
  2543. /*
  2544.   XClearArea (display, window, x, y + (2 * FHEIGHT), FWIDTH * 10, FHEIGHT, 0);
  2545. */
  2546.   XSetForeground (display, gc, background);
  2547.   XFillRectangle (display, pixmap, gc, x, y + (FHEIGHT * 2), FWIDTH * 10, FHEIGHT);
  2548.  
  2549.   if (avg_percent_avail_swap_used < 0)
  2550.     avg_percent_avail_swap_used = 0;
  2551.  
  2552.   if (percent_avail_swap_used < 0)
  2553.     percent_avail_swap_used = 0;
  2554.  
  2555.   if (percent_avail_swap_used > res.availSwapUsedAlarmThreshhold)
  2556.     AvailSwappixel = colorAvailSwapUsedAlarm.pixel;
  2557.   else if (percent_avail_swap_used > res.availSwapUsedWarningThreshhold)
  2558.     AvailSwappixel = colorAvailSwapUsedWarning.pixel;
  2559.   else
  2560.     AvailSwappixel = colorAvailSwapUsed.pixel;
  2561.  
  2562.   XSetForeground (display, gc, AvailSwappixel);
  2563.   sprintf (numstr, "%3d  %3d", avg_percent_avail_swap_used,
  2564.        percent_avail_swap_used);
  2565. /*
  2566.   XDrawString (display, window, gc,
  2567.            x + _MEMCUR, y + FASCENT + (2 * FHEIGHT), numstr, 8);
  2568. */
  2569.   XDrawString (display, pixmap, gc,
  2570.            x + _MEMCUR, y + FASCENT + (2 * FHEIGHT), numstr, 8);
  2571.  
  2572.   XSetForeground (display, gc, colorNumeric.pixel);
  2573.  
  2574.   x += (FWIDTH * 1);
  2575.   update_Single_PctScale (window, display, gc, DrawAreaXYWH, pixmap,
  2576.               x + _MEMSCALE, y,
  2577.         SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].width - (x + _MEMSCALE),
  2578.               "M", 100,
  2579.               percent_memory_used,
  2580.               Mempixel);
  2581.  
  2582.   update_Single_PctScale (window, display, gc, DrawAreaXYWH, pixmap,
  2583.               x + _MEMSCALE, y + FHEIGHT,
  2584.         SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].width - (x + _MEMSCALE),
  2585.               "M", 100,
  2586.               percent_swap_used,
  2587.               Swappixel);
  2588.  
  2589.   update_Single_PctScale (window, display, gc, DrawAreaXYWH, pixmap,
  2590.               x + _MEMSCALE, y + (2 * FHEIGHT),
  2591.         SP -> SEPERATE_WINDOWS_LIST[BUTTON_mem].width - (x + _MEMSCALE),
  2592.               "M", 100,
  2593.               percent_avail_swap_used,
  2594.               AvailSwappixel);
  2595.  
  2596. #ifdef DEBUG2
  2597.   fprintf (stdout, "leaving update_CpuScale\n");
  2598. #endif
  2599.  
  2600.  
  2601. }                /* end of update_MemScale */
  2602.  
  2603. /* vi: set tabstop=4 shiftwidth=4: */
  2604. /* end of scales.c */
  2605.